<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>
<html dir="ltr" xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>JSON-LD 1.0</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />

<!--  
  === NOTA BENE ===
  For the three scripts below, if your spec resides on dev.w3 you can check them
  out in the same tree and use relative links so that they'll work offline,
   -->



<style>
.diff { font-weight:bold; color:#0a3; }
ol.algorithm.update { margin-left: 2em; }
ol.algorithm.update>li { list-style-type: none; }
ol.algorithm.update>li>span.list-number {
  display:block;
  float: left; 
  margin-left: -3.5em;
}
</style>
<style type="text/css">
/*****************************************************************
 * ReSpec CSS
 * Robin Berjon (robin at berjon dot com)
 * v0.05 - 2009-07-31
 *****************************************************************/


/* --- INLINES --- */
em.rfc2119 { 
    text-transform:     lowercase;
    font-variant:       small-caps;
    font-style:         normal;
    color:              #900;
}

h1 acronym, h2 acronym, h3 acronym, h4 acronym, h5 acronym, h6 acronym, a acronym,
h1 abbr, h2 abbr, h3 abbr, h4 abbr, h5 abbr, h6 abbr, a abbr {
    border: none;
}

dfn {
    font-weight:    bold;
}

a.internalDFN {
    color:  inherit;
    border-bottom:  1px solid #99c;
    text-decoration:    none;
}

a.externalDFN {
    color:  inherit;
    border-bottom:  1px dotted #ccc;
    text-decoration:    none;
}

a.bibref {
    text-decoration:    none;
}

code {
    color:  #ff4500;
}


/* --- WEB IDL --- */
pre.idl {
    border-top: 1px solid #90b8de;
    border-bottom: 1px solid #90b8de;
    padding:    1em;
    line-height:    120%;
}

pre.idl::before {
    content:    "WebIDL";
    display:    block;
    width:      150px;
    background: #90b8de;
    color:  #fff;
    font-family:    initial;
    padding:    3px;
    font-weight:    bold;
    margin: -1em 0 1em -1em;
}

.idlType {
    color:  #ff4500;
    font-weight:    bold;
    text-decoration:    none;
}

/*.idlModule*/
/*.idlModuleID*/
/*.idlInterface*/
.idlInterfaceID {
    font-weight:    bold;
    color:  #005a9c;
}

.idlSuperclass {
    font-style: italic;
    color:  #005a9c;
}

/*.idlAttribute*/
.idlAttrType, .idlFieldType {
    color:  #005a9c;
}
.idlAttrName, .idlFieldName {
    color:  #ff4500;
}
.idlAttrName a, .idlFieldName a {
    color:  #ff4500;
    border-bottom:  1px dotted #ff4500;
    text-decoration: none;
}

/*.idlMethod*/
.idlMethType {
    color:  #005a9c;
}
.idlMethName {
    color:  #ff4500;
}
.idlMethName a {
    color:  #ff4500;
    border-bottom:  1px dotted #ff4500;
    text-decoration: none;
}

/*.idlParam*/
.idlParamType {
    color:  #005a9c;
}
.idlParamName {
    font-style: italic;
}

.extAttr {
    color:  #666;
}

/*.idlConst*/
.idlConstType {
    color:  #005a9c;
}
.idlConstName {
    color:  #ff4500;
}
.idlConstName a {
    color:  #ff4500;
    border-bottom:  1px dotted #ff4500;
    text-decoration: none;
}

/*.idlException*/
.idlExceptionID {
    font-weight:    bold;
    color:  #c00;
}

.idlTypedefID, .idlTypedefType {
    color:  #005a9c;
}

.idlRaises, .idlRaises a.idlType, .idlRaises a.idlType code, .excName a, .excName a code {
    color:  #c00;
    font-weight:    normal;
}

.excName a {
    font-family:    monospace;
}

.idlRaises a.idlType, .excName a.idlType {
    border-bottom:  1px dotted #c00;
}

.excGetSetTrue, .excGetSetFalse, .prmNullTrue, .prmNullFalse, .prmOptTrue, .prmOptFalse {
    width:  45px;
    text-align: center;
}
.excGetSetTrue, .prmNullTrue, .prmOptTrue { color:  #0c0; }
.excGetSetFalse, .prmNullFalse, .prmOptFalse { color:  #c00; }

.idlImplements a {
    font-weight:    bold;
}

dl.attributes, dl.methods, dl.constants, dl.fields {
    margin-left:    2em;
}

.attributes dt, .methods dt, .constants dt, .fields dt {
    font-weight:    normal;
}

.attributes dt code, .methods dt code, .constants dt code, .fields dt code {
    font-weight:    bold;
    color:  #000;
    font-family:    monospace;
}

.attributes dt code, .fields dt code {
    background:  #ffffd2;
}

.attributes dt .idlAttrType code, .fields dt .idlFieldType code {
    color:  #005a9c;
    background:  transparent;
    font-family:    inherit;
    font-weight:    normal;
    font-style: italic;
}

.methods dt code {
    background:  #d9e6f8;
}

.constants dt code {
    background:  #ddffd2;
}

.attributes dd, .methods dd, .constants dd, .fields dd {
    margin-bottom:  1em;
}

table.parameters, table.exceptions {
    border-spacing: 0;
    border-collapse:    collapse;
    margin: 0.5em 0;
    width:  100%;
}
table.parameters { border-bottom:  1px solid #90b8de; }
table.exceptions { border-bottom:  1px solid #deb890; }

.parameters th, .exceptions th {
    color:  #fff;
    padding:    3px 5px;
    text-align: left;
    font-family:    initial;
    font-weight:    normal;
    text-shadow:    #666 1px 1px 0;
}
.parameters th { background: #90b8de; }
.exceptions th { background: #deb890; }

.parameters td, .exceptions td {
    padding:    3px 10px;
    border-top: 1px solid #ddd;
    vertical-align: top;
}

.parameters tr:first-child td, .exceptions tr:first-child td {
    border-top: none;
}

.parameters td.prmName, .exceptions td.excName, .exceptions td.excCodeName {
    width:  100px;
}

.parameters td.prmType {
    width:  120px;
}

table.exceptions table {
    border-spacing: 0;
    border-collapse:    collapse;
    width:  100%;
}

/* --- TOC --- */
.toc a {
    text-decoration:    none;
}

a .secno {
    color:  #000;
}

/* --- TABLE --- */
table.simple {
    border-spacing: 0;
    border-collapse:    collapse;
    border-bottom:  3px solid #005a9c;
}

.simple th {
    background: #005a9c;
    color:  #fff;
    padding:    3px 5px;
    text-align: left;
}

.simple th[scope="row"] {
    background: inherit;
    color:  inherit;
    border-top: 1px solid #ddd;
}

.simple td {
    padding:    3px 10px;
    border-top: 1px solid #ddd;
}

.simple tr:nth-child(even) {
    background: #f0f6ff;
}

/* --- DL --- */
.section dd > p:first-child {
    margin-top: 0;
}

.section dd > p:last-child {
    margin-bottom: 0;
}

.section dd {
    margin-bottom:  1em;
}

.section dl.attrs dd, .section dl.eldef dd {
    margin-bottom:  0;
}

/* --- EXAMPLES --- */
pre.example {
    border-top: 1px solid #ff4500;
    border-bottom: 1px solid #ff4500;
    padding:    1em;
    margin-top: 1em;
}

pre.example::before {
    content:    "Example";
    display:    block;
    width:      150px;
    background: #ff4500;
    color:  #fff;
    font-family:    initial;
    padding:    3px;
    font-weight:    bold;
    margin: -1em 0 1em -1em;
}

/* --- EDITORIAL NOTES --- */
.issue {
    padding:    1em;
    margin: 1em 0em 0em;
    border: 1px solid #f00;
    background: #ffc;
}

.issue::before {
    content:    "Issue";
    display:    block;
    width:  150px;
    margin: -1.5em 0 0.5em 0;
    font-weight:    bold;
    border: 1px solid #f00;
    background: #fff;
    padding:    3px 1em;
}

.note {
    margin: 1em 0em 0em;
    padding:    1em;
    border: 2px solid #cff6d9;
    background: #e2fff0;
}

.note::before {
    content:    "Note";
    display:    block;
    width:  150px;
    margin: -1.5em 0 0.5em 0;
    font-weight:    bold;
    border: 1px solid #cff6d9;
    background: #fff;
    padding:    3px 1em;
}

/* --- Best Practices --- */
div.practice {
    border: solid #bebebe 1px;
    margin: 2em 1em 1em 2em;
}

span.practicelab {
    margin: 1.5em 0.5em 1em 1em;
    font-weight: bold;
    font-style: italic;
}

span.practicelab   { background: #dfffff; }

span.practicelab {
    position: relative;
    padding: 0 0.5em;
    top: -1.5em;
}

p.practicedesc {
    margin: 1.5em 0.5em 1em 1em;
}

@media screen {
    p.practicedesc {
        position: relative;
        top: -2em;
        padding: 0;
        margin: 1.5em 0.5em -1em 1em;
}

/* --- SYNTAX HIGHLIGHTING --- */
pre.sh_sourceCode {
  background-color: white;
  color: black;
  font-style: normal;
  font-weight: normal;
}

pre.sh_sourceCode .sh_keyword { color: #005a9c; font-weight: bold; }           /* language keywords */
pre.sh_sourceCode .sh_type { color: #666; }                            /* basic types */
pre.sh_sourceCode .sh_usertype { color: teal; }                             /* user defined types */
pre.sh_sourceCode .sh_string { color: red; font-family: monospace; }        /* strings and chars */
pre.sh_sourceCode .sh_regexp { color: orange; font-family: monospace; }     /* regular expressions */
pre.sh_sourceCode .sh_specialchar { color: 	#ffc0cb; font-family: monospace; }  /* e.g., \n, \t, \\ */
pre.sh_sourceCode .sh_comment { color: #A52A2A; font-style: italic; }         /* comments */
pre.sh_sourceCode .sh_number { color: purple; }                             /* literal numbers */
pre.sh_sourceCode .sh_preproc { color: #00008B; font-weight: bold; }       /* e.g., #include, import */
pre.sh_sourceCode .sh_symbol { color: blue; }                            /* e.g., *, + */
pre.sh_sourceCode .sh_function { color: black; font-weight: bold; }         /* function calls and declarations */
pre.sh_sourceCode .sh_cbracket { color: red; }                              /* block brackets (e.g., {, }) */
pre.sh_sourceCode .sh_todo { font-weight: bold; background-color: #00FFFF; }   /* TODO and FIXME */

/* Predefined variables and functions (for instance glsl) */
pre.sh_sourceCode .sh_predef_var { color: #00008B; }
pre.sh_sourceCode .sh_predef_func { color: #00008B; font-weight: bold; }

/* for OOP */
pre.sh_sourceCode .sh_classname { color: teal; }

/* line numbers (not yet implemented) */
pre.sh_sourceCode .sh_linenum { display: none; }

/* Internet related */
pre.sh_sourceCode .sh_url { color: blue; text-decoration: underline; font-family: monospace; }

/* for ChangeLog and Log files */
pre.sh_sourceCode .sh_date { color: blue; font-weight: bold; }
pre.sh_sourceCode .sh_time, pre.sh_sourceCode .sh_file { color: #00008B; font-weight: bold; }
pre.sh_sourceCode .sh_ip, pre.sh_sourceCode .sh_name { color: #006400; }

/* for Prolog, Perl... */
pre.sh_sourceCode .sh_variable { color: #006400; }

/* for LaTeX */
pre.sh_sourceCode .sh_italics { color: #006400; font-style: italic; }
pre.sh_sourceCode .sh_bold { color: #006400; font-weight: bold; }
pre.sh_sourceCode .sh_underline { color: #006400; text-decoration: underline; }
pre.sh_sourceCode .sh_fixed { color: green; font-family: monospace; }
pre.sh_sourceCode .sh_argument { color: #006400; }
pre.sh_sourceCode .sh_optionalargument { color: purple; }
pre.sh_sourceCode .sh_math { color: orange; }
pre.sh_sourceCode .sh_bibtex { color: blue; }

/* for diffs */
pre.sh_sourceCode .sh_oldfile { color: orange; }
pre.sh_sourceCode .sh_newfile { color: #006400; }
pre.sh_sourceCode .sh_difflines { color: blue; }

/* for css */
pre.sh_sourceCode .sh_selector { color: purple; }
pre.sh_sourceCode .sh_property { color: blue; }
pre.sh_sourceCode .sh_value { color: #006400; font-style: italic; }

/* other */
pre.sh_sourceCode .sh_section { color: black; font-weight: bold; }
pre.sh_sourceCode .sh_paren { color: red; }
pre.sh_sourceCode .sh_attribute { color: #006400; }

</style><style type="text/css">ol.algorithm { counter-reset:numsection; list-style-type: none; }
ol.algorithm li { margin: 0.5em 0; }
ol.algorithm li:before { font-weight: bold; counter-increment: numsection; content: counters(numsection, ".") ") "; }

</style><link href="http://www.w3.org/StyleSheets/TR/w3c-unofficial" rel="stylesheet" type="text/css" charset="utf-8" /></head>

<body style="display: inherit; "><div class="head"><p></p><h1 class="title" id="title">JSON-LD 1.0</h1><h2 id="subtitle">A Context-based JSON Serialization for Linking Data</h2><h2 id="unofficial-draft-17-august-2011">Unofficial Draft 17 August 2011</h2><dl><dt>Editors:</dt><dd><a href="http://manu.sporny.org/">Manu Sporny</a>, <a href="http://digitalbazaar.com/">Digital Bazaar</a></dd>
<dd><a href="http://greggkellogg.net/">Gregg Kellogg</a>, Kellogg Associates</dd>
<dd><a href="http://digitalbazaar.com/">Dave Longley</a>, <a href="http://digitalbazaar.com/">Digital Bazaar</a></dd>
<dt>Authors:</dt><dd><a href="http://digitalbazaar.com/">Manu Sporny</a>, <a href="http://digitalbazaar.com/">Digital Bazaar</a></dd>
<dd><a href="http://greggkellogg.net/">Gregg Kellogg</a>, Kellogg Associates</dd>
<dd><a href="http://digitalbazaar.com/">Dave Longley</a>, <a href="http://digitalbazaar.com/">Digital Bazaar</a></dd>
<dd><a href="http://webbackplane.com/">Mark Birbeck</a>, <a href="http://webbackplane.com/">Backplane Ltd.</a></dd>
</dl><p>This document is also available in this non-normative format: <a href="diff-20110808.html">diff to previous version</a>.</p><p class="copyright">This document is licensed under a <a class="subfoot" href="http://creativecommons.org/licenses/by/3.0/" rel="license">Creative Commons Attribution 3.0 License</a>.</p><hr /></div>
<div id="abstract" class="introductory section"><h2>Abstract</h2>
<p>
JSON [<cite><a class="bibref" rel="biblioentry" href="#bib-RFC4627">RFC4627</a></cite>] has proven to be a highly useful object serialization and 
messaging format. In an attempt to harmonize the representation of Linked Data 
in JSON, this specification outlines a common JSON representation format for 
expressing directed graphs; mixing both Linked Data and non-Linked Data in 
a single document. 
</p>
</div><div id="sotd" class="introductory section"><h2>Status of This Document</h2><p>This document is merely a public working draft of a potential specification. It has no official standing of any kind and does not represent the support or consensus of any standards organisation.</p>
<p>This document is an experimental work in progress.</p>

<!--  <p>
This document has been reviewed by W3C Members, by software
developers, and by other W3C groups and interested parties, and is
endorsed by the Director as a W3C Recommendation. It is a stable
document and may be used as reference material or cited from another
document. W3C's role in making the Recommendation is to draw attention
to the specification and to promote its widespread deployment. This
enhances the functionality and interoperability of the Web.
</p>  -->

</div><div id="toc" class="section"><h2 class="introductory">Table of Contents</h2><ul class="toc"><li class="tocline"><a href="#introduction" class="tocxref"><span class="secno">1. </span>Introduction</a><ul class="toc"><li class="tocline"><a href="#how-to-read-this-document" class="tocxref"><span class="secno">1.1 </span>How to Read this Document</a></li><li class="tocline"><a href="#contributing" class="tocxref"><span class="secno">1.2 </span>Contributing</a></li></ul></li><li class="tocline"><a href="#design" class="tocxref"><span class="secno">2. </span>Design</a><ul class="toc"><li class="tocline"><a href="#goals-and-rationale" class="tocxref"><span class="secno">2.1 </span>Goals and Rationale</a></li><li class="tocline"><a href="#linked-data" class="tocxref"><span class="secno">2.2 </span>Linked Data</a></li><li class="tocline"><a href="#linking-data" class="tocxref"><span class="secno">2.3 </span>Linking Data</a></li><li class="tocline"><a href="#the-context" class="tocxref"><span class="secno">2.4 </span>The Context</a><ul class="toc"><li class="tocline"><a href="#inside-a-context" class="tocxref"><span class="secno">2.4.1 </span>Inside a Context</a></li></ul></li><li class="tocline"><a href="#from-json-to-json-ld" class="tocxref"><span class="secno">2.5 </span>From JSON to JSON-LD</a></li></ul></li><li class="tocline"><a href="#basic-concepts" class="tocxref"><span class="secno">3. </span>Basic Concepts</a><ul class="toc"><li class="tocline"><a href="#iris" class="tocxref"><span class="secno">3.1 </span>IRIs</a></li><li class="tocline"><a href="#identifying-the-subject" class="tocxref"><span class="secno">3.2 </span>Identifying the Subject</a></li><li class="tocline"><a href="#specifying-the-type" class="tocxref"><span class="secno">3.3 </span>Specifying the Type</a></li><li class="tocline"><a href="#strings" class="tocxref"><span class="secno">3.4 </span>Strings</a></li><li class="tocline"><a href="#string-internationalization" class="tocxref"><span class="secno">3.5 </span>String Internationalization</a></li><li class="tocline"><a href="#datatypes" class="tocxref"><span class="secno">3.6 </span>Datatypes</a></li><li class="tocline"><a href="#multiple-objects-for-a-single-property" class="tocxref"><span class="secno">3.7 </span>Multiple Objects for a Single Property</a></li><li class="tocline"><a href="#multiple-typed-literals-for-a-single-property" class="tocxref"><span class="secno">3.8 </span>Multiple Typed Literals for a Single Property</a></li><li class="tocline"><a href="#expansion" class="tocxref"><span class="secno">3.9 </span>Expansion</a></li><li class="tocline"><a href="#compaction" class="tocxref"><span class="secno">3.10 </span>Compaction</a></li><li class="tocline"><a href="#framing" class="tocxref"><span class="secno">3.11 </span>Framing</a></li></ul></li><li class="tocline"><a href="#advanced-concepts" class="tocxref"><span class="secno">4. </span>Advanced Concepts</a><ul class="toc"><li class="tocline"><a href="#curies" class="tocxref"><span class="secno">4.1 </span>CURIEs</a></li><li class="tocline"><a href="#automatic-typing" class="tocxref"><span class="secno">4.2 </span>Automatic Typing</a></li><li class="tocline"><a href="#type-coercion" class="tocxref"><span class="secno">4.3 </span>Type Coercion</a></li><li class="tocline"><a href="#chaining" class="tocxref"><span class="secno">4.4 </span>Chaining</a></li><li class="tocline"><a href="#identifying-unlabeled-nodes" class="tocxref"><span class="secno">4.5 </span>Identifying Unlabeled Nodes</a></li><li class="tocline"><a href="#overriding-keywords" class="tocxref"><span class="secno">4.6 </span>Overriding Keywords</a></li><li class="tocline"><a href="#normalization" class="tocxref"><span class="secno">4.7 </span>Normalization</a></li></ul></li><li class="tocline"><a href="#the-application-programming-interface" class="tocxref"><span class="secno">5. </span>The Application Programming Interface</a><ul class="toc"><li class="tocline"><a href="#jsonldprocessor" class="tocxref"><span class="secno">5.1 </span>JSONLDProcessor</a><ul class="toc"><li class="tocline"><a href="#methods" class="tocxref"><span class="secno">5.1.1 </span>Methods</a></li></ul></li><li class="tocline"><a href="#jsonldprocessorcallback" class="tocxref"><span class="secno">5.2 </span>JSONLDProcessorCallback</a><ul class="toc"><li class="tocline"><a href="#methods-1" class="tocxref"><span class="secno">5.2.1 </span>Methods</a></li></ul></li><li class="tocline"><a href="#jsonldtriplecallback" class="tocxref"><span class="secno">5.3 </span>JSONLDTripleCallback</a><ul class="toc"><li class="tocline"><a href="#methods-2" class="tocxref"><span class="secno">5.3.1 </span>Methods</a></li></ul></li></ul></li><li class="tocline"><a href="#algorithms" class="tocxref"><span class="secno">6. </span>Algorithms</a><ul class="toc"><li class="tocline"><a href="#syntax-tokens-and-keywords" class="tocxref"><span class="secno">6.1 </span>Syntax Tokens and Keywords</a></li><li class="tocline"><a href="#algorithm-terms" class="tocxref"><span class="secno">6.2 </span>Algorithm Terms</a></li><li class="tocline"><a href="#context-1" class="tocxref"><span class="secno">6.3 </span>Context</a><ul class="toc"><li class="tocline"><a href="#coerce" class="tocxref"><span class="secno">6.3.1 </span>Coerce</a></li><li class="tocline"><a href="#initial-context" class="tocxref"><span class="secno">6.3.2 </span>Initial Context</a></li></ul></li><li class="tocline"><a href="#iri-expansion" class="tocxref"><span class="secno">6.4 </span>IRI Expansion</a></li><li class="tocline"><a href="#iri-compaction" class="tocxref"><span class="secno">6.5 </span>IRI Compaction</a></li><li class="tocline"><a href="#value-expansion" class="tocxref"><span class="secno">6.6 </span>Value Expansion</a></li><li class="tocline"><a href="#value-compaction" class="tocxref"><span class="secno">6.7 </span>Value Compaction</a></li><li class="tocline"><a href="#expansion-1" class="tocxref"><span class="secno">6.8 </span>Expansion</a><ul class="toc"><li class="tocline"><a href="#expansion-algorithm" class="tocxref"><span class="secno">6.8.1 </span>Expansion Algorithm</a></li></ul></li><li class="tocline"><a href="#compaction-1" class="tocxref"><span class="secno">6.9 </span>Compaction</a><ul class="toc"><li class="tocline"><a href="#compaction-algorithm" class="tocxref"><span class="secno">6.9.1 </span>Compaction Algorithm</a></li></ul></li><li class="tocline"><a href="#framing-1" class="tocxref"><span class="secno">6.10 </span>Framing</a><ul class="toc"><li class="tocline"><a href="#framing-algorithm-terms" class="tocxref"><span class="secno">6.10.1 </span>Framing Algorithm Terms</a></li><li class="tocline"><a href="#framing-algorithm" class="tocxref"><span class="secno">6.10.2 </span>Framing Algorithm</a></li></ul></li><li class="tocline"><a href="#normalization-1" class="tocxref"><span class="secno">6.11 </span>Normalization</a><ul class="toc"><li class="tocline"><a href="#normalization-algorithm-terms" class="tocxref"><span class="secno">6.11.1 </span>Normalization Algorithm Terms</a></li><li class="tocline"><a href="#normalization-state" class="tocxref"><span class="secno">6.11.2 </span>Normalization State</a></li><li class="tocline"><a href="#normalization-algorithm" class="tocxref"><span class="secno">6.11.3 </span>Normalization Algorithm</a></li><li class="tocline"><a href="#node-relabeling-algorithm" class="tocxref"><span class="secno">6.11.4 </span>Node Relabeling Algorithm</a></li><li class="tocline"><a href="#deterministic-labeling-algorithm" class="tocxref"><span class="secno">6.11.5 </span>Deterministic Labeling Algorithm</a></li><li class="tocline"><a href="#shallow-comparison-algorithm" class="tocxref"><span class="secno">6.11.6 </span>Shallow Comparison Algorithm</a></li><li class="tocline"><a href="#object-comparison-algorithm" class="tocxref"><span class="secno">6.11.7 </span>Object Comparison Algorithm</a></li><li class="tocline"><a href="#deep-comparison-algorithm" class="tocxref"><span class="secno">6.11.8 </span>Deep Comparison Algorithm</a></li><li class="tocline"><a href="#node-serialization-algorithm" class="tocxref"><span class="secno">6.11.9 </span>Node Serialization Algorithm</a></li><li class="tocline"><a href="#serialization-label-generation-algorithm" class="tocxref"><span class="secno">6.11.10 </span>Serialization Label Generation Algorithm</a></li><li class="tocline"><a href="#combinatorial-serialization-algorithm" class="tocxref"><span class="secno">6.11.11 </span>Combinatorial Serialization Algorithm</a></li><li class="tocline"><a href="#mapping-serialization-algorithm" class="tocxref"><span class="secno">6.11.12 </span>Mapping Serialization Algorithm</a></li><li class="tocline"><a href="#label-serialization-algorithm" class="tocxref"><span class="secno">6.11.13 </span>Label Serialization Algorithm</a></li></ul></li><li class="tocline"><a href="#data-round-tripping" class="tocxref"><span class="secno">6.12 </span>Data Round Tripping</a></li><li class="tocline"><a href="#rdf-conversion" class="tocxref"><span class="secno">6.13 </span>RDF Conversion</a><ul class="toc"><li class="tocline"><a href="#overview" class="tocxref"><span class="secno">6.13.1 </span>Overview</a></li><li class="tocline"><a href="#rdf-conversion-algorithm-terms" class="tocxref"><span class="secno">6.13.2 </span>RDF Conversion Algorithm Terms</a></li><li class="tocline"><a href="#rdf-conversion-algorithm" class="tocxref"><span class="secno">6.13.3 </span>RDF Conversion Algorithm</a></li></ul></li></ul></li><li class="tocline"><a href="#experimental-concepts" class="tocxref"><span class="secno">7. </span>Experimental Concepts</a><ul class="toc"><li class="tocline"><a href="#disjoint-graphs" class="tocxref"><span class="secno">7.1 </span>Disjoint Graphs</a></li><li class="tocline"><a href="#lists" class="tocxref"><span class="secno">7.2 </span>Lists</a><ul class="toc"><li class="tocline"><a href="#expansion-2" class="tocxref"><span class="secno">7.2.1 </span>Expansion</a></li><li class="tocline"><a href="#normalization-2" class="tocxref"><span class="secno">7.2.2 </span>Normalization</a></li><li class="tocline"><a href="#rdf-conversion-1" class="tocxref"><span class="secno">7.2.3 </span>RDF Conversion</a></li></ul></li></ul></li><li class="tocline"><a href="#markup-examples" class="tocxref"><span class="secno">A. </span>Markup Examples</a><ul class="toc"><li class="tocline"><a href="#rdfa" class="tocxref"><span class="secno">A.1 </span>RDFa</a></li><li class="tocline"><a href="#microformats" class="tocxref"><span class="secno">A.2 </span>Microformats</a></li><li class="tocline"><a href="#microdata" class="tocxref"><span class="secno">A.3 </span>Microdata</a></li><li class="tocline"><a href="#mashing-up-vocabularies" class="tocxref"><span class="secno">A.4 </span>Mashing Up Vocabularies</a></li><li class="tocline"><a href="#acknowledgements" class="tocxref"><span class="secno">A.5 </span>Acknowledgements</a></li></ul></li><li class="tocline"><a href="#references" class="tocxref"><span class="secno">B. </span>References</a><ul class="toc"><li class="tocline"><a href="#normative-references" class="tocxref"><span class="secno">B.1 </span>Normative references</a></li><li class="tocline"><a href="#informative-references" class="tocxref"><span class="secno">B.2 </span>Informative references</a></li></ul></li></ul></div>



<div id="introduction" class="section">

<!-- OddPage -->
<h2><span class="secno">1. </span>Introduction</h2>

<p>
JSON, as specified in [<cite><a class="bibref" rel="biblioentry" href="#bib-RFC4627">RFC4627</a></cite>], is a simple language for representing 
data on the Web. Linked Data is a technique for describing content across 
different 
documents or Web sites. Web resources are described using <a class="tref internalDFN" title="IRI" href="#dfn-iri">IRI</a>s, 
and typically are dereferencable entities that may be used to find more 
information, creating a "Web of Knowledge". JSON-LD is intended to be a simple 
publishing method for expressing not only Linked Data in JSON, but for adding
semantics to existing JSON.
</p>

<p>
JSON-LD is designed as a light-weight syntax that can be used to express 
Linked Data. It is primarily intended to be a way to express Linked Data 
in Javascript and other Web-based programming environments. It is also 
useful when building interoperable Web Services and when storing Linked 
Data in JSON-based document storage engines. It is practical and designed 
to be as simple as possible, utilizing the large number of JSON parsers 
and existing code that is in use today. It is designed to be able to 
express key-value pairs, RDF data, RDFa [<cite><a class="bibref" rel="biblioentry" href="#bib-RDFA-CORE">RDFA-CORE</a></cite>] data, Microformats 
[<cite><a class="bibref" rel="biblioentry" href="#bib-MICROFORMATS">MICROFORMATS</a></cite>] data, and Microdata [<cite><a class="bibref" rel="biblioentry" href="#bib-MICRODATA">MICRODATA</a></cite>]. That is, it supports 
every major Web-based structured data model in use today. 
</p>

<p>
The syntax does not require many applications to change their JSON, but 
easily add meaning by adding context in a way that is either in-band or 
out-of-band. The syntax is designed to not disturb already deployed systems 
running on JSON, but provide a smooth migration path from JSON to JSON with 
added semantics. Finally, the format is intended to be fast to parse, fast to 
generate, stream-based and document-based processing compatible, and require
a very small memory footprint in order to operate.
</p>

<div id="how-to-read-this-document" class="section">
<h3><span class="secno">1.1 </span>How to Read this Document</h3>

<p>
This document is a detailed specification for a serialization of JSON for Linked
data. The document is primarily intended for the following audiences:
</p>

<ul>
  <li>Web developers that want to understand the design decisions and 
  language syntax for JSON-LD.</li>
  <li>Software developers that want to encode Microformats, RDFa, or Microdata 
  in a way that is cross-language compatible via JSON.</li>
  <li>Software developers that want to implement processors and APIs for 
  JSON-LD.</li>
</ul>

<p>
To understand the basics in this specification you must first be familiar with 
JSON, which is detailed in [<cite><a class="bibref" rel="biblioentry" href="#bib-RFC4627">RFC4627</a></cite>]. To understand the API and how it is
intended to operate  in a programming environment, it is useful to have working 
knowledge of the JavaScript programming language [<cite><a class="bibref" rel="biblioentry" href="#bib-ECMA-262">ECMA-262</a></cite>] and 
WebIDL [<cite><a class="bibref" rel="biblioentry" href="#bib-WEBIDL">WEBIDL</a></cite>]. To understand how JSON-LD maps to RDF, it is helpful to be 
familiar with the basic RDF concepts [<cite><a class="bibref" rel="biblioentry" href="#bib-RDF-CONCEPTS">RDF-CONCEPTS</a></cite>].</p>

<p>
  Examples may contain references to existing vocabularies and use abbreviations in <a class="tref internalDFN" title="CURIE" href="#dfn-curie">CURIE</a>s and source code. The following is a list of all vocabularies and their abbreviations, as used in this document:
</p>
<ul>
  <li>The <a href="http://purl.org/dc/terms/">Dublin Core</a>
  vocabulary (abbreviation: <code>dc</code>, e.g., <code>dc:title</code>)</li>
  <li>The <a href="http://xmlns.com/foaf/0.1/">Friend of a Friend</a>
  vocabulary (abbreviation: <code>foaf</code>, e.g., <code>foaf:knows</code>)</li>
  <li>The <a href="http://www.w3.org/1999/02/22-rdf-syntax-ns#">RDF</a>
  vocabulary (abbreviation: <code>rdf</code>, e.g., <code>rdf:type</code>)</li>
  <li>The <a href="http://www.w3.org/2001/XMLSchema#">XSD</a>
  vocabulary (abbreviation: <code>xsd</code>, e.g., <code>xsd:integer</code>)</li>
</ul>

<p>
  JSON [<cite><a class="bibref" rel="biblioentry" href="#bib-RFC4627">RFC4627</a></cite>] defines several terms which are used throughout this document:
  </p><dl>
    <dt><dfn title="JSON_Object" id="dfn-json_object">JSON Object</dfn></dt><dd>
      An object structure is represented as a pair of curly brackets surrounding zero or
      more name/value pairs (or members). A name is a <a class="tref internalDFN" title="string" href="#dfn-string">string</a>. A single colon comes after
      each name, separating the name from the value. A single comma separates a value
      from a following name. The names within an object <em class="rfc2119" title="should">should</em> be unique.
    </dd>
    <dt><dfn title="array" id="dfn-array">array</dfn></dt><dd>
      An <em>array</em> is an ordered collection of values. An array begins with [ (left bracket) and ends with ]
      (right bracket). Values are separated by , (comma). Within JSON-LD, array order is not preserved, unless
      specific markup is provided (see <a href="#lists">Lists</a>). This is because the basic data model of JSON-LD
      <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a>, which is inherently unordered.
    </dd>
    <dt><dfn title="string" id="dfn-string">string</dfn></dt><dd>
      A string is a sequence of zero or more Unicode characters, wrapped in double quotes, using backslash escapes. A
      character is represented as a single character string. A string is very much like a C or Java string.
    </dd>
    <dt><dfn title="number" id="dfn-number">number</dfn></dt><dd>
      A number is very much like a C or Java number, except that the octal and hexadecimal formats are not used.
    </dd>
    <dt><dfn title="true" id="dfn-true">true</dfn> and <dfn title="false" id="dfn-false">false</dfn></dt><dd>
      Boolean values.
    </dd>
    <dt><dfn title="null" id="dfn-null">null</dfn></dt><dd>
      The use of the <em>null</em> value is undefined within JSON-LD.
    </dd>
  </dl>
<p></p>
</div>

<div id="contributing" class="section">
<h3><span class="secno">1.2 </span>Contributing</h3>

<p>There are a number of ways that one may participate in the development of
this specification:</p>

<ul>
<li>Technical discussion typically occurs on the public mailing list:
<a href="http://lists.w3.org/Archives/Public/public-linked-json/">public-linked-json@w3.org</a>
</li>

<li><a href="http://json-ld.org/minutes/">Public teleconferences</a> are held 
on Tuesdays at 1500UTC on the second and fourth week of each month.
</li>

<li>Specification bugs and issues should be reported in the 
<a href="https://github.com/json-ld/json-ld.org/issues">issue tracker</a>.</li>

<li><a href="https://github.com/json-ld/json-ld.org/tree/main/spec">Source code</a> for the 
specification can be found on Github.</li>

<li>The <a href="http://webchat.freenode.net/?channels=#json-ld">#json-ld</a> 
IRC channel is available for real-time discussion on irc.freenode.net.</li>
</ul>

</div>

</div>

<div id="design" class="section">

<!-- OddPage -->
<h2><span class="secno">2. </span>Design</h2>

<p>The following section outlines the design goals and rationale behind the 
JSON-LD markup language.
</p>

<div id="goals-and-rationale" class="section">
<h3><span class="secno">2.1 </span>Goals and Rationale</h3>

<p>
A number of design considerations were explored during the creation of this 
markup language:
</p>

<dl>
 <dt>Simplicity</dt>
 <dd>Developers need only know JSON and three keywords to use the basic 
 functionality in JSON-LD. No extra processors or software libraries are
 necessary to use JSON-LD in its most basic form. The language attempts to
 ensure that developers have an easy learning curve.</dd>
 <dt>Compatibility</dt>
 <dd>The JSON-LD markup must be 100% compatible with JSON. This ensures that
 all of the standard JSON libraries work seamlessly with JSON-LD documents.</dd>
 <dt>Expressiveness</dt>
 <dd>The syntax must be able to express directed graphs, which have been proven
 to be able to simply express almost every real world data model.</dd>
 <dt>Terseness</dt>
 <dd>The JSON-LD syntax must be very terse and human readable, requiring as
 little as possible from the developer.</dd>
 
<!-- <dt>Pragmatism</dt>
 <dd>Mixing the expression of pure Linked Data with data that is not
 linked was an approach that was driven by pragmatism. JSON-LD attempts to be
 more practical than theoretical in its approach to Linked Data.</dd> -->

 <dt>Zero Edits, most of the time</dt>
 <dd>JSON-LD provides a mechanism that allows developers to specify 
 context in a way that is out-of-band. This allows organizations that have
 already deployed large JSON-based infrastructure to add meaning to their
 JSON in a way that is not disruptive to their day-to-day operations and is
 transparent to their current customers. At times, mapping JSON to 
 a graph representation can become difficult. In these instances, rather than 
 having JSON-LD support esoteric markup, we chose not to support the use case 
 and support a simplified syntax instead. So, while Zero Edits was a goal,
 it was not always possible without adding great complexity to the language.
 </dd>
 <dt>Streaming</dt>
 <dd>The format supports both document-based and stream-based processing.</dd>
</dl>
</div>

<div id="linked-data" class="section">
<h3><span class="secno">2.2 </span>Linked Data</h3>
<p>
The following definition for <a class="tref internalDFN" title="Linked_Data" href="#dfn-linked_data">Linked Data</a> is the one that will 
be used for this specification.
</p>
<ol>
  <li><dfn title="Linked_Data" id="dfn-linked_data">Linked Data</dfn> is a set of documents, each containing a representation of a linked data graph.</li>
  <li>A <dfn title="linked_data_graph" id="dfn-linked_data_graph">linked data graph</dfn> is an unordered labeled directed graph, where nodes are <a class="tref internalDFN" title="subject" href="#dfn-subject">subject</a>s or <a class="tref internalDFN" title="object" href="#dfn-object">object</a>s, and edges are properties.</li>
  <li>A <dfn title="subject" id="dfn-subject">subject</dfn> is any node in a <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a> with at least one outgoing edge.</li>
  <li>A <a class="tref internalDFN" title="subject" href="#dfn-subject">subject</a> <em class="rfc2119" title="should">should</em> be labeled with an IRI.</li>
  <li>A <dfn title="property" id="dfn-property">property</dfn> is an edge of the <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a>.</li>
  <li>A <a class="tref internalDFN" title="property" href="#dfn-property">property</a> <em class="rfc2119" title="should">should</em> be labeled with an IRI.</li>
  <li>An <dfn title="object" id="dfn-object">object</dfn> is a node in a <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a> with at least one incoming edge.</li>
  <li>An <a class="tref internalDFN" title="object" href="#dfn-object">object</a> <em class="rfc2119" title="may">may</em> be labeled with an IRI.</li>
  <li>An IRI that is a label in a <a class="tref internalDFN" title="linked_data_graph" href="#dfn-linked_data_graph">linked data graph</a> <em class="rfc2119" title="should">should</em> be dereferencable to a <a class="tref internalDFN" title="Linked_Data" href="#dfn-linked_data">Linked Data</a> document describing the labeled <a class="tref internalDFN" title="subject" href="#dfn-subject">subject</a>, <a class="tref internalDFN" title="object" href="#dfn-object">object</a> or <a class="tref internalDFN" title="property" href="#dfn-property">property</a>.</li>
  <li>A <dfn title="literal" id="dfn-literal">literal</dfn> is an <a class="tref internalDFN" title="object" href="#dfn-object">object</a> with a label that is not an IRI</li>
</ol>

<p>
Note that the definition for <a class="tref internalDFN" title="Linked_Data" href="#dfn-linked_data">Linked Data</a> above is silent on the 
topic of unlabeled nodes. Unlabeled nodes are not considered 
<a class="tref internalDFN" title="Linked_Data" href="#dfn-linked_data">Linked Data</a>. However, this specification allows for the expression
of unlabled nodes, as most graph-based data sets on the Web contain a number 
of associated nodes that are not named and thus are not directly 
de-referenceable.
</p>
</div>

<div id="linking-data" class="section">
<h3><span class="secno">2.3 </span>Linking Data</h3>

<p>
An Internationalized Resource Identifier 
(<dfn title="IRI" id="dfn-iri"><abbr title="Internationalized Resource Identifier">IRI</abbr></dfn>),
as described in [<cite><a class="bibref" rel="biblioentry" href="#bib-RFC3987">RFC3987</a></cite>], is a mechanism for representing unique 
identifiers on the web. In <a class="tref internalDFN" title="Linked_Data" href="#dfn-linked_data">Linked Data</a>, an IRI is commonly 
used for expressing a <a class="tref internalDFN" title="subject" href="#dfn-subject">subject</a>, a <a class="tref internalDFN" title="property" href="#dfn-property">property</a> or an 
<a class="tref internalDFN" title="object" href="#dfn-object">object</a>.
</p>

<p>JSON-LD defines a mechanism to map JSON values to IRIs. This does not mean 
that JSON-LD requires every key or value to be an IRI, but rather ensures that
keys and values can be mapped to IRIs if the developer so desires to transform
their data into Linked Data. There are a few techniques that can ensure 
that developers will generate good Linked Data for the Web. JSON-LD 
formalizes those techniques.
</p>

<p>We will be using the following JSON markup as the example for the
rest of this section:
</p>

<pre class="example">
{
  "name": "Manu Sporny",
  "homepage": "http://manu.sporny.org/",
  "avatar": "http://twitter.com/account/profile_image/manusporny"
}</pre>
</div>

<div id="the-context" class="section">
<h3><span class="secno">2.4 </span>The Context</h3>

<p>In JSON-LD, a context is used to allow developers to map <a class="tref internalDFN" title="term" href="#dfn-term">term</a>s 
to <a class="tref internalDFN" title="IRI" href="#dfn-iri">IRI</a>s. A <dfn title="term" id="dfn-term">term</dfn> is a short word that <em class="rfc2119" title="may">may</em> be expanded
to an <a class="tref internalDFN" title="IRI" href="#dfn-iri">IRI</a>. The semantic web, just like the document-based 
web, uses IRIs for unambiguous identification. The idea is that these 
<a class="tref internalDFN" title="term" href="#dfn-term">term</a>s mean something that may be of use to other developers.
For example, the term <code>name</code> may map directly to the IRI 
<code>http://xmlns.com/foaf/0.1/name</code>. This allows JSON-LD documents to 
be constructed using the common JSON practice of simple name/value pairs while
ensuring that the data is useful outside of the database or page in which it
resides.
</p>

<p>These Linked Data <a class="tref internalDFN" title="term" href="#dfn-term">term</a>s are typically collected in a context and
then used by adding a single line to the JSON markup above:</p>

<pre class="example">
{
  <span class="diff">"@context": "http://example.org/json-ld-contexts/person",</span>
  "name": "Manu Sporny",
  "homepage": "http://manu.sporny.org/",
  "avatar": "http://twitter.com/account/profile_image/manusporny"
}</pre>

<p>The addition above transforms the previous JSON document into a JSON document
with added semantics because the <code>@context</code> specifies how the
<strong>name</strong>, <strong>homepage</strong>, and <strong>avatar</strong> 
terms map to IRIs. 
Mapping those keys to IRIs gives the data global context. If two 
developers use the same IRI to describe a property, they are more than likely
expressing the same concept. This allows both developers to re-use each others
data without having to agree to how their data will inter-operate on a 
site-by-site basis.</p>

<p>
The semantic web uses a special type of document called a 
<em>Web Vocabulary</em> to define <a class="tref internalDFN" title="term" href="#dfn-term">term</a>s. A context is a type of
Web vocabulary.
Typically, these Web Vocabulary documents have <a class="tref internalDFN" title="prefix" href="#dfn-prefix">prefix</a>es associated
with them and contain a number of <a class="tref internalDFN" title="term" href="#dfn-term">term</a> declarations. A
<dfn title="prefix" id="dfn-prefix">prefix</dfn>, like a <a class="tref internalDFN" title="term" href="#dfn-term">term</a>, is a short word that expands
to a Web Vocabulary IRI. <a class="tref internalDFN" title="Prefix" href="#dfn-prefix">Prefix</a>es are helpful when a developer
wants to mix multiple vocabularies together in a context, but does not want
to go to the trouble of defining every single term in every single vocabulary.
Some Web Vocabularies may have 10-20 terms defined. If a developer wants to use 
3-4 different vocabularies, the number of terms that 
would have to be declared in a single context would become quite large. To 
reduce the number of different terms that must be defined, JSON-LD also allows 
prefixes to be used to compact IRIs.
</p><p>

</p><p>For example, the IRI <code>http://xmlns.com/foaf/0.1/</code> 
specifies a Web Vocabulary which may be represented using the
<code>foaf</code> <a class="tref internalDFN" title="prefix" href="#dfn-prefix">prefix</a>. The <code>foaf</code> Web Vocabulary
contains a term called <strong>name</strong>. If you join the 
<code>foaf</code> <a class="tref internalDFN" title="prefix" href="#dfn-prefix">prefix</a> with the <strong>name</strong> suffix, 
you can build a compact IRI that will expand out into an absolute IRI for the
<code>http://xmlns.com/foaf/0.1/name</code> vocabulary term.
That is, the compact IRI, or short-form, is <code>foaf:name</code> and the 
expanded-form is <code>http://xmlns.com/foaf/0.1/name</code>. This vocabulary 
term is used to specify a person's name.
</p>

<p>Developers, and machines, are able to use this IRI (plugging it
directly into a web browser, for instance) to go to the term and get a 
definition of what the term means. Much like we can use WordNet today to 
see the 
<a href="http://wordnetweb.princeton.edu/perl/webwn?s=definition">definition</a>
of words in the English language. Developers and machines need the same sort of 
dictionary of terms. IRIs provide a way to ensure that these terms
are unambiguous.
</p>

<p>The context provides a collection of vocabulary <a class="tref internalDFN" title="term" href="#dfn-term">term</a>s and 
<a class="tref internalDFN" title="prefix" href="#dfn-prefix">prefix</a>es that can be used to expand JSON keys and values into
<a class="tref internalDFN" title="IRI" href="#dfn-iri">IRI</a>s.</p>

<div id="inside-a-context" class="section">
<h4><span class="secno">2.4.1 </span>Inside a Context</h4>

<p>In the previous section, the developer used the <code>@context</code>
keyword to pull in an external context. That context document, if 
de-referenced, would look something like this:</p>

<pre class="example">
{
    "name": "http://xmlns.com/foaf/0.1/name",
    "homepage": "http://xmlns.com/foaf/0.1/homepage",
    "avatar": "http://xmlns.com/foaf/0.1/avatar"
}</pre>

<p>A JSON-LD context document is a simple mapping from <a class="tref internalDFN" title="term" href="#dfn-term">term</a>s and
<a class="tref internalDFN" title="prefix" href="#dfn-prefix">prefix</a>es to expanded values such as IRIs or keywords. Contexts may also contain datatype information
for certain <a class="tref internalDFN" title="term" href="#dfn-term">term</a>s as well as other processing instructions for
the JSON-LD processor.
</p>

<p>Contexts may be specified in-line. This ensures that JSON-LD documents
can be processed when a JSON-LD processor does not have access to the Web.</p>

<p>
JSON-LD strives to ensure that developers don't have to change the JSON
that is going into and being returned from their Web applications. This means
that developers can also specify a context for JSON data in an out-of-band
fashion via the API. The API is described later in this document. A JSON-LD 
aware Web Service <em class="rfc2119" title="may">may</em> also define a context that will be pre-loaded for all
calls to the service. This allows services that have previously been publishing
and receiving JSON data to accept JSON-LD data without requiring client 
software to change.
</p>

</div>

</div>

<div id="from-json-to-json-ld" class="section">
<h3><span class="secno">2.5 </span>From JSON to JSON-LD</h3>

<p>If a set of terms such as, <strong>name</strong>, <strong>homepage</strong>, 
and <strong>avatar</strong>,
are defined in a context, and that context is used to resolve the
names in JSON objects, machines are able to automatically expand the terms to 
something meaningful and unambiguous, like this:</p>

<pre class="example">
{
  "<span class="diff">http://xmlns.com/foaf/0.1/name</span>": "Manu Sporny",
  "<span class="diff">http://xmlns.com/foaf/0.1/homepage</span>": "http://manu.sporny.org"
  "<span class="diff">http://rdfs.org/sioc/ns#avatar</span>": "http://twitter.com/account/profile_image/manusporny"
}</pre>

<p>Doing this allows JSON to be unambiguously machine-readable without
requiring developers that use JSON to drastically change their workflow.</p>
</div>

</div>



<div id="basic-concepts" class="section">

<!-- OddPage -->
<h2><span class="secno">3. </span>Basic Concepts</h2>

<p>JSON-LD is designed to ensure that Linked Data concepts can be marked 
up in a way that is simple to understand and author by Web developers. In many
cases, regular JSON markup can become Linked Data with the simple addition
of a context. As more JSON-LD features are used, more semantics are added
to the JSON markup.</p>

<div id="iris" class="section">
<h3><span class="secno">3.1 </span>IRIs</h3>

<p>Expressing IRIs are fundamental to Linked Data as that is how most 
<a class="tref internalDFN" title="subject" href="#dfn-subject">subject</a>s and many <a class="tref internalDFN" title="object" href="#dfn-object">object</a> are named. IRIs can be 
expressed in a variety of different ways in JSON-LD.</p>

<ol>
  <li>In general, <a class="tref internalDFN" title="term" href="#dfn-term">term</a>s in the key position in 
    a <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a> that have a mapping to an IRI or another key in the context are
    expanded to an IRI by JSON-LD processors. There are special rules for 
    processing keys in <code>@context</code> and when dealing with keys that 
    start with the <code>@subject</code> character.</li>
  <li>An IRI is generated for the value specified using <code>@subject</code>, 
    if it is a <a class="tref internalDFN" title="string" href="#dfn-string">string</a>.</li>
  <li>An IRI is generated for the value specified using <code>@type</code>.</li>
  <li>An IRI is generated for the value specified using the <code>@iri</code> 
    keyword.</li>
  <li>An IRI is generated when there are <code>@coerce</code> rules in 
    effect for a key named <code>@iri</code>.</li>
</ol>

<p>IRIs can be expressed directly in the key position like so:
</p>

<pre class="example">
{
...
  "<span class="diff">http://xmlns.com/foaf/0.1/name</span>": "Manu Sporny",
...
}</pre>

<p>In the example above, the key 
<code>http://xmlns.com/foaf/0.1/name</code> is interpreted as an IRI, as 
opposed to being interpreted as a string.</p>

<p>Term expansion occurs for IRIs if a term is defined within the 
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>:</p>

<pre class="example">
{
  "<span class="diff">@context</span>": {"<span class="diff">name</span>": "<span class="diff">http://xmlns.com/foaf/0.1/name</span>"},
...
  "<span class="diff">name</span>": "Manu Sporny",
...
}</pre>

<p><a class="tref internalDFN" title="Prefix" href="#dfn-prefix">Prefix</a>es are expanded when used in keys:</p>

<pre class="example">
{
  "<span class="diff">@context</span>": {"<span class="diff">name</span>": "<span class="diff">http://xmlns.com/foaf/0.1/name</span>"},
...
  "<span class="diff">name</span>": "Manu Sporny",
...
}</pre>

<p><code>name</code> above will automatically expand out to the IRI
<code>http://xmlns.com/foaf/0.1/name</code>.</p>

<p>An IRI is generated when a value is associated with a key using 
the <code>@iri</code> keyword:</p>

<pre class="example">
{
...
  "homepage": { "<span class="diff">@iri</span>": "http://manu.sporny.org" }
...
}</pre>

<p>If type coercion rules are specified in the <code>@context</code> for
a particular vocabulary term, an IRI is generated:</p>

<pre class="example">
{<span class="diff">
  "@context": 
  {
    ...
    "@coerce": 
    {
      "@iri": "homepage"
    }
  }</span>
...
  "homepage": "http://manu.sporny.org/",
...
}</pre>

<p>Even though the value <code>http://manu.sporny.org/</code> is a <a class="tref internalDFN" title="string" href="#dfn-string">string</a>,
the type coercion rules will transform the value into an IRI when processed
by a JSON-LD Processor</p>

</div>

<div id="identifying-the-subject" class="section">
<h3><span class="secno">3.2 </span>Identifying the Subject</h3>

<p>
  <a class="tref internalDFN" title="IRI" href="#dfn-iri">IRI</a>s are a fundamental concept of Linked Data, and nodes should have a de-referencable
  identifier used to name and locate them. For nodes to be truely linked, de-referencing the identifier
  should result in a representation of that node. Associating an IRI with a node tells an application
  that the returned document contains a description of of the identifier requested.
</p>
<p>
  JSON-LD documents may also contain descriptions of other nodes, so it is necessary to be able to
  uniquely identify each node which may be externally referenced.
</p>
<p>A <a class="tref internalDFN" title="subject" href="#dfn-subject">subject</a> of a node is declared using the <code>@subject</code> key. The subject is the
first piece of information needed by the JSON-LD processor in order to
create the (subject, property, object) tuple, also known as a triple.</p>

<pre class="example">
{
...
  "<span class="diff">@subject</span>": "<span class="diff">http://example.org/people#joebob</span>",
...
}</pre>

<p>The example above would set the subject to the IRI 
<code>http://example.org/people#joebob</code>.
</p>

</div>

<div id="specifying-the-type" class="section">
<h3><span class="secno">3.3 </span>Specifying the Type</h3>

<p>The type of a particular subject can be specified using the 
<code>@type</code> key. Specifying the type in this way will generate a 
triple of the form (subject, type, type-uri).</p>

<p>To be Linked Data, types should be uniquely identified by an <a class="tref internalDFN" title="IRI" href="#dfn-iri">IRI</a>.</p>

<pre class="example">
{
...
  "@subject": "http://example.org/people#joebob",
  "<span class="diff">@type</span>": "<span class="diff">http://xmlns.com/foaf/0.1/Person</span>",
...
}</pre>

<p>The example above would generate the following triple if the JSON-LD 
document is mapped to RDF (in N-Triples notation):</p>

<pre class="example">
&lt;http://example.org/people#joebob&gt; 
   &lt;http://www.w3.org/1999/02/22-rdf-syntax-ns#type&gt;
      &lt;http://xmlns.com/foaf/0.1/Person&gt; .</pre>

</div>

<div id="strings" class="section">
<h3><span class="secno">3.4 </span>Strings</h3>

<p>Regular text strings, also referred to as <dfn title="plain_literal" id="dfn-plain_literal">plain literal</dfn>s, are 
easily expressed using regular JSON <a class="tref internalDFN" title="string" href="#dfn-string">string</a>s.</p>

<pre class="example">
{
...
  "name": "<span class="diff">Mark Birbeck</span>",
...
}</pre>

</div>

<div id="string-internationalization" class="section">
<h3><span class="secno">3.5 </span>String Internationalization</h3>

<p>JSON-LD makes an assumption that strings with associated language encoding 
information are not very common when used in JavaScript and Web Services. 
Thus, it takes a little more effort to express strings with associated 
language information.</p>

<pre class="example">
{
...
  "name": <span class="diff">
  {
    "@literal": "花澄",
    "@language": "ja"
  }</span>
...
}</pre>

<p>The example above would generate a <a class="tref internalDFN" title="plain_literal" href="#dfn-plain_literal">plain literal</a> for 
<em>花澄</em> and associate the <code>ja</code> language code with the triple 
that is generated. Languages <em class="rfc2119" title="must">must</em> be expressed in [<cite><a class="bibref" rel="biblioentry" href="#bib-BCP47">BCP47</a></cite>] format.</p>

</div>

<div id="datatypes" class="section">
<h3><span class="secno">3.6 </span>Datatypes</h3>

<p>
  A value with an associated datatype, also known as a 
  <dfn title="typed_literal" id="dfn-typed_literal">typed literal</dfn>, is indicated by associating a literal with
  an IRI which indicates the typed literal's datatype. Typed literals may be 
  expressed in JSON-LD in three ways:
</p>

<ol>
  <li>By utilizing the <code>@coerce</code> keyword.</li>
  <li>By utilizing the expanded form for specifying objects.</li>
  <li>By using a native JSON datatype.</li>
</ol>

<p>The first example uses the <code>@coerce</code> keyword to express a
typed literal:</p>

<pre class="example">
{<span class="diff">
  "@context": 
  {
    "modified":  "http://purl.org/dc/terms/modified",
    "dateTime": "http://www.w3.org/2001/XMLSchema#dateTime"
    "@coerce": 
    {
      "dateTime": "modified"
    }
  }</span>
...
  "modified": "2010-05-29T14:17:39+02:00",
...
}</pre>

<p>The second example uses the expanded form for specifying objects:</p>

<pre class="example">
{
...
  "modified": <span class="diff">
  {
    "@literal": "2010-05-29T14:17:39+02:00",
    "@datatype": "dateTime"
  }</span>
...
}</pre>

<p>Both examples above would generate an object with the literal value of
<code>2010-05-29T14:17:39+02:00</code> and the datatype of
<code>http://www.w3.org/2001/XMLSchema#dateTime</code>.</p>

<p>The third example uses a built-in native JSON type, a <a class="tref internalDFN" title="number" href="#dfn-number">number</a>, to 
express a datatype:</p>

<pre class="example">
{
...
  "@subject": "http://example.org/people#joebob",
  "age": <span class="diff">31</span>
...
}</pre>

<p>The example above would generate the following triple:</p>

<pre class="example">
&lt;http://example.org/people#joebob&gt; 
   &lt;http://xmlns.com/foaf/0.1/age&gt; 
      "31"^^&lt;http://www.w3.org/2001/XMLSchema#integer&gt; .</pre>

</div>

<div id="multiple-objects-for-a-single-property" class="section">
<h3><span class="secno">3.7 </span>Multiple Objects for a Single Property</h3>

<p>A JSON-LD author can express multiple triples in a compact way by using
<a class="tref internalDFN" title="array" href="#dfn-array">array</a>s. If a subject has multiple values for the same property, the author
<em class="rfc2119" title="may">may</em> express each property as an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>.</p>

<p class="note">In JSON-LD, Multiple objects on a property are not ordered. This is because typically graphs
are not inherently ordered data structures. To see more on creating ordered collections
in JSON-LD, see <a href="#lists">Lists</a>.
</p>

<pre class="example">
{
...
  "@subject": "http://example.org/people#joebob",
  "nick": <span class="diff">["joe", "bob", "jaybee"]</span>,
...
}</pre>

<p>The markup shown above would generate the following triples:</p>

<pre class="example">
&lt;http://example.org/people#joebob&gt; 
   &lt;http://xmlns.com/foaf/0.1/nick&gt;
      "joe" .
&lt;http://example.org/people#joebob&gt; 
   &lt;http://xmlns.com/foaf/0.1/nick&gt;
      "bob" .
&lt;http://example.org/people#joebob&gt; 
   &lt;http://xmlns.com/foaf/0.1/nick&gt;
      "jaybee" .</pre>

</div>

<div id="multiple-typed-literals-for-a-single-property" class="section">
<h3><span class="secno">3.8 </span>Multiple Typed Literals for a Single Property</h3>

<p>Multiple <a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">typed literal</a>s may also be expressed using the expanded
form for objects:</p>

<pre class="example">
{
...
  "@subject": "http://example.org/articles/8",
  "modified": <span class="diff">
  [
    {
      "@literal": "2010-05-29T14:17:39+02:00",
      "@datatype": "dateTime"
    },
    {
      "@literal": "2010-05-30T09:21:28-04:00",
      "@datatype": "dateTime"
    }
  ]</span>
...
}</pre>

<p>The markup shown above would generate the following triples:</p>

<pre class="example">
&lt;http://example.org/articles/8&gt; 
   &lt;http://purl.org/dc/terms/modified&gt;
      "2010-05-29T14:17:39+02:00"^^http://www.w3.org/2001/XMLSchema#dateTime .
&lt;http://example.org/articles/8&gt; 
   &lt;http://purl.org/dc/terms/modified&gt;
      "2010-05-30T09:21:28-04:00"^^http://www.w3.org/2001/XMLSchema#dateTime .</pre>

</div>

<div id="expansion" class="section">
<h3><span class="secno">3.9 </span>Expansion</h3>

<p>Expansion is the process of taking a JSON-LD document and applying a 
context such that all IRI, datatypes, and literal values are expanded so
that the context is no longer necessary. JSON-LD document expansion 
is typically used when re-mapping JSON-LD documents to application-specific
JSON documents or as a part of the <a href="#normalization">Normalization</a>
process.</p>

<p>For example, assume the following JSON-LD input document:</p>

<pre class="example">
{
   "name": "Manu Sporny",
   "homepage": "http://manu.sporny.org/",
   "@context": 
   {
      "name": "http://xmlns.com/foaf/0.1/name",
      "homepage": "http://xmlns.com/foaf/0.1/homepage",
      "@coerce": 
      {
         "@iri": "homepage"
      }
   }
}</pre>

<p>Running the JSON-LD Expansion algorithm against the JSON-LD input document 
provided above would result in the following output:</p>

<pre class="example">
{
   "http://xmlns.com/foaf/0.1/name": "Manu Sporny",
   "http://xmlns.com/foaf/0.1/homepage": 
   {
      "@iri": "http://manu.sporny.org/"
   }
}</pre>

</div> 

<div id="compaction" class="section">
<h3><span class="secno">3.10 </span>Compaction</h3>

<p>Compaction is the process of taking a JSON-LD document and applying a 
context such that the most compact form of the document is generated. JSON
is typically expressed in a very compact, key-value format. That is, full
IRIs are rarely used as keys. At times, a JSON-LD document may be received
that is not in its most compact form. JSON-LD, via the API, provides a way
to compact a JSON-LD document.
</p>

<p>For example, assume the following JSON-LD input document:</p>

<pre class="example">
{
   "http://xmlns.com/foaf/0.1/name": "Manu Sporny",
   "http://xmlns.com/foaf/0.1/homepage": 
   {
      "@iri": "http://manu.sporny.org/"
   }
}</pre>

<p>Additionally, assume the following developer-supplied JSON-LD context:</p>

<pre class="example">
{
   "name": "http://xmlns.com/foaf/0.1/name",
   "homepage": "http://xmlns.com/foaf/0.1/homepage",
   "@coerce": 
   {
      "@iri": ["homepage"]
   }
}</pre>

<p>Running the JSON-LD Compaction algorithm given the context supplied above 
against the JSON-LD input document provided above would result in the following
output:</p>

<pre class="example">
{
   "name": "Manu Sporny",
   "homepage": "http://manu.sporny.org/",
   "@context": 
   {
      "name": "http://xmlns.com/foaf/0.1/name",
      "homepage": "http://xmlns.com/foaf/0.1/homepage",
      "@coerce": 
      {
         "@iri": "homepage"
      }
   }
}</pre>

<p>The compaction algorithm also enables the developer to map any expanded
format into an application-specific compacted format. While the context 
provided above mapped <code>http://xmlns.com/foaf/0.1/name</code> to
<strong>name</strong>, it could have also mapped it to any arbitrary string
provided by the developer.
</p>

</div>

<div id="framing" class="section">
<h3><span class="secno">3.11 </span>Framing</h3>

<p>A JSON-LD document is a representation of a directed graph. A single
directed graph can have many different serializations, each expressing
exactly the same information. Developers typically work with trees, represented as
<a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a>s. While mapping a graph to 
a tree can be done, the layout of the end result must be specified in advance. 
A <dfn title="Frame" id="dfn-frame">Frame</dfn> can be used by a developer on a JSON-LD document to 
specify a deterministic layout for a graph.
</p>

<p>Framing is the process of taking a JSON-LD document, which expresses a
graph of information, and applying a specific graph layout 
(called a <a class="tref internalDFN" title="Frame" href="#dfn-frame">Frame</a>).
</p>

<p>The JSON-LD document below expresses a library, a book and a chapter:</p>

<pre class="example">
{
  "@coerce": {
    "Book":         "http://example.org/vocab#Book",
    "Chapter":      "http://example.org/vocab#Chapter",
    "contains":     "http://example.org/vocab#contains",
    "creator":      "http://purl.org/dc/terms/creator"
    "description":  "http://purl.org/dc/terms/description"
    "Library":      "http://example.org/vocab#Library",
    "title":        "http://purl.org/dc/terms/title",
    "@coerce": 
    {
      "@iri": "ex:contains"
    },
  },
  "@subject": 
  [{
    "@subject": "http://example.com/library",
    "@type": "Library",
    "contains": "http://example.org/library/the-republic"
  }, 
  {
    "@subject": "http://example.org/library/the-republic",
    "@type": "Book",
    "creator": "Plato",
    "title": "The Republic",
    "contains": "http://example.org/library/the-republic#introduction"
  }, 
  {
    "@subject": "http://example.org/library/the-republic#introduction",
    "@type": "Chapter",
    "description": "An introductory chapter on The Republic.",
    "title": "The Introduction"
  }]
}</pre>

<p>Developers typically like to operate on items in a hierarchical, tree-based
fashion. Ideally, a developer would want the data above sorted into top-level
libraries, then the books that are contained in each library, and then the
chapters contained in each book. To achieve that layout, the developer can
define the following <a class="tref internalDFN" title="frame" href="#dfn-frame">frame</a>:</p>

<pre class="example">
{
  "@context": {
    "Book":         "http://example.org/vocab#Book",
    "Chapter":      "http://example.org/vocab#Chapter",
    "contains":     "http://example.org/vocab#contains",
    "creator":      "http://purl.org/dc/terms/creator"
    "description":  "http://purl.org/dc/terms/description"
    "Library":      "http://example.org/vocab#Library",
    "title":        "http://purl.org/dc/terms/title"
  },
  "@type": "Library",
  "contains": {
    "@type": "Book",
    "contains": {
      "@type": "Chapter"
    }
  }
}</pre>

<p>When the framing algorithm is run against the previously defined 
JSON-LD document, paired with the <a class="tref internalDFN" title="frame" href="#dfn-frame">frame</a> above, the following
JSON-LD document is the end result:</p>

<pre class="example">
{
  "@context": {
    "Book":         "http://example.org/vocab#Book",
    "Chapter":      "http://example.org/vocab#Chapter",
    "contains":     "http://example.org/vocab#contains",
    "creator":      "http://purl.org/dc/terms/creator"
    "description":  "http://purl.org/dc/terms/description"
    "Library":      "http://example.org/vocab#Library",
    "title":        "http://purl.org/dc/terms/title"
  },
  "@subject": "http://example.org/library",
  "@type": "Library",
  "contains": {
    <span class="diff">"@subject": "http://example.org/library/the-republic",</span>
    "@type": "Book",
    <span class="diff">"creator": "Plato",</span>
    <span class="diff">"title": "The Republic",</span>
    "contains": {
      <span class="diff">"@subject": "http://example.org/library/the-republic#introduction",</span>
      "@type": "Chapter",
      <span class="diff">"description": "An introductory chapter on The Republic.",</span>
      <span class="diff">"title": "The Introduction"</span>
    },
  },
}</pre>

<p>The JSON-LD framing algorithm allows developers to query by example and
force a specific tree layout to a JSON-LD document.
</p>

</div>

</div>

<div id="advanced-concepts" class="section">

<!-- OddPage -->
<h2><span class="secno">4. </span>Advanced Concepts</h2>

<p>JSON-LD has a number of features that provide functionality above and beyond
the core functionality described above. The following sections outline the
features that are specific to JSON-LD.
</p>

<div id="curies" class="section">
  <h3><span class="secno">4.1 </span>CURIEs</h3>
  <p>
    Concepts in Linked Data documents may draw on a number of different vocabularies. The @vocab mechanism
    is useful to easily associate types and properties with a specific vocabulary, but when many vocabularies
    are used, this becomes difficult. Consider the following example:
  </p>
  <pre class="example">
{
  "@context": {
    <span class="diff">"dc": "http://purl.org/dc/elements/1.1/",</span>
    <span class="diff">"ex": "http://example.org/vocab#"</span>
  },
  "@subject": "http://example.org/library",
  "@type": <span class="diff">"ex:Library"</span>,
  <span class="diff">"ex:contains"</span>: {
    "@subject": "http://example.org/library/the-republic",
    "@type": <span class="diff">"ex:Book"</span>,
    <span class="diff">"dc:creator"</span>: "Plato",
    <span class="diff">"dc:title"</span>: "The Republic",
    <span class="diff">"ex:contains"</span>: {
      "@subject": "http://example.org/library/the-republic#introduction",
      "@type": <span class="diff">"ex:Chapter"</span>,
      <span class="diff">"dc:description"</span>: "An introductory chapter on The Republic.",
      <span class="diff">"dc:title"</span>: "The Introduction"
    },
  },
}</pre>
  <p>
    In this example, two different vocabularies are identified with prefixes, and used as type
    and property values using the CURIE notation.
  </p>
  <p>
    A <dfn title="CURIE" id="dfn-curie">CURIE</dfn> is a compact way of describing an <a class="tref internalDFN" title="IRI" href="#dfn-iri">IRI</a>. The term actually comes
    from Compact URI.
    Generally, a CURIE is composed of a <em>prefix</em> and a <em>suffix</em> separated by a ':'. In
    JSON-LD, the prefix may be the empty string, denoting the <dfn title="default_prefix" id="dfn-default_prefix">default prefix</dfn>.
  </p>
  <p>
    CURIEs are defined more formally in [<cite><a class="bibref" rel="biblioentry" href="#bib-RDFA-CORE">RDFA-CORE</a></cite>] <cite><a href="http://www.w3.org/TR/rdfa-core/#s_curies">section 6 "CURIE Syntax Definition"</a></cite>.
  </p>
</div>

<div id="automatic-typing" class="section">
<h3><span class="secno">4.2 </span>Automatic Typing</h3>

<p>Since JSON is capable of expressing typed information such as doubles, 
integers, and boolean values. As demonstrated below, JSON-LD utilizes that 
information to create <a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">typed literal</a>s:</p>

<pre class="example">
{
...
  // The following two values are automatically converted to a type of xsd:double
  // and both values are equivalent to each other.
  "measure:cups": <span class="diff">5.3</span>,
  "measure:cups": <span class="diff">5.3e0</span>,
  // The following value is automatically converted to a type of xsd:double as well
  "space:astronomicUnits": <span class="diff">6.5e73</span>,
  // The following value should never be converted to a language-native type
  "measure:stones": <span class="diff">{ "@literal": "4.8", "@datatype": "xsd:decimal" }</span>,
  // This value is automatically converted to having a type of xsd:integer
  "chem:protons": <span class="diff">12</span>,
  // This value is automatically converted to having a type of xsd:boolean
  "sensor:active": <span class="diff">true</span>,
...
}</pre>

<p class="note">When dealing with a number of modern programming languages,
including JavaScript ECMA-262, there is no distinction between 
<strong>xsd:decimal</strong> and <strong>xsd:double</strong> values. That is, 
the <a class="tref internalDFN" title="number" href="#dfn-number">number</a> <code>5.3</code> and the <a class="tref internalDFN" title="number" href="#dfn-number">number</a> 
<code>5.3e0</code> are treated as if they were the same. When converting from 
JSON-LD to a language-native format and back, datatype information is lost in a 
number of these languages. Thus, one could say that <code>5.3</code> is a 
<strong>xsd:decimal</strong> and <code>5.3e0</code> is an 
<strong>xsd:double</strong> in JSON-LD, but when both values are 
converted to a language-native format the datatype difference between the two 
is lost because the machine-level representation will almost always be a 
<strong>double</strong>. 
Implementers should be aware of this potential round-tripping issue between 
<strong>xsd:decimal</strong> and <strong>xsd:double</strong>. Specifically
objects with a datatype of <strong>xsd:decimal</strong> <em class="rfc2119" title="must not">must not</em> be converted
to a language native type.
</p>

</div>

<div id="type-coercion" class="section">
<h3><span class="secno">4.3 </span>Type Coercion</h3>

<p>JSON-LD supports the coercion of values to particular data types. 
Type coercion allows someone deploying JSON-LD to coerce the incoming or 
outgoing types to the proper data type based on a mapping of data type IRIs to 
property types. Using type coercion, one may convert simple JSON data to 
properly typed RDF data.</p>

<p>The example below demonstrates how a JSON-LD author can coerce values to 
<a class="tref internalDFN" title="plain_literal" href="#dfn-plain_literal">plain literal</a>s, <a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">typed literal</a>s and IRIs.</p>

<pre class="example">
{
  "@context": 
  {  
     "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
     "xsd": "http://www.w3.org/2001/XMLSchema#",
     "name": "http://xmlns.com/foaf/0.1/name",
     "age": "http://xmlns.com/foaf/0.1/age",
     "homepage": "http://xmlns.com/foaf/0.1/homepage",
<span class="diff">     "@coerce":
     {
        "xsd:integer": "age",
        "@iri": "homepage"
     }</span>
  },
  "name": "John Smith",
  "age": <span class="diff">"41"</span>,
  "homepage": <span class="diff">"http://example.org/home/"</span>
}</pre>

<p>The example above would generate the following triples:</p>

<pre class="example">
_:bnode1
   &lt;http://xmlns.com/foaf/0.1/name&gt;
      "John Smith" .
_:bnode1
   &lt;http://xmlns.com/foaf/0.1/age&gt;
      "41"^^http://www.w3.org/2001/XMLSchema#integer .
_:bnode1
   &lt;http://xmlns.com/foaf/0.1/homepage&gt;
      &lt;http://example.org/home/&gt; .</pre>

</div>

<div id="chaining" class="section">
  <h3><span class="secno">4.4 </span>Chaining</h3>
  <p>
    Object <dfn title="chaining" id="dfn-chaining">chaining</dfn> is a JSON-LD feature that allows an author to 
    use the definition of JSON-LD objects as <a class="tref internalDFN" title="property" href="#dfn-property">property</a> values. This 
    is a commonly used mechanism for creating a parent-child relationship 
    between two <a class="tref internalDFN" title="subject" href="#dfn-subject">subject</a>s.
  </p>
  <p>The example shows an two subjects related by a property from the first 
  subject:</p>

  <pre class="example">
{
...
  "name": "Manu Sporny",
  "<span class="diff">knows</span>": {
    "<span class="diff">@type</span>": "<span class="diff">Person</span>",
    "<span class="diff">name</span>": "<span class="diff">Gregg Kellogg</span>",
  }
...
}</pre>
  
  <p>
    An object definition, like the one used above, <em class="rfc2119" title="may">may</em> be used as a 
    JSON value at any point in JSON-LD.
  </p>
</div>

<div id="identifying-unlabeled-nodes" class="section">
<h3><span class="secno">4.5 </span>Identifying Unlabeled Nodes</h3>

<p>At times, it becomes necessary to be able to express information without
being able to specify the subject. Typically, this type of node is called
an unlabeled node or a blank node. In JSON-LD, unlabeled node identifiers are 
automatically created if a subject is not specified using the 
<code>@subject</code> keyword. However, authors may provide identifiers for
unlabeled nodes by using the special <code>_</code> (underscore) <a class="tref internalDFN" title="CURIE" href="#dfn-curie">CURIE</a> 
prefix.</p>

<pre class="example">
{
...
  "@subject": "<span class="diff">_:foo</span>",
...
}</pre>

<p>The example above would set the subject to <code>_:foo</code>, which can
then be used later on in the JSON-LD markup to refer back to the 
unlabeled node. This practice, however, is usually frowned upon when
generating Linked Data. If a developer finds that they refer to the unlabeled
node more than once, they should consider naming the node using a resolve-able
IRI.
</p>

</div>

<div id="overriding-keywords" class="section">
<h3><span class="secno">4.6 </span>Overriding Keywords</h3>

<p>JSON-LD allows all of the syntax keywords, except for <code>@context</code>,
to be overridden. This feature allows more legacy JSON content to be supported 
by JSON-LD. It also allows developers to design domain-specific implementations 
using only the JSON-LD context.</p>

<pre class="example">
{
  "@context": 
  {  
     <span class="diff">"url": "@subject"</span>,
     <span class="diff">"a": "@type"</span>,
     "name": "http://schema.org/name"
  },
  "url": "http://example.com/about#gregg",
  "a": "http://schema.org/Person",
  "name": "Gregg Kellogg"
}</pre>

<p>In the example above, the <code>@subject</code> and <code>@type</code> 
keywords have been overridden by <strong>url</strong> and 
<strong>a</strong>, respectively.
</p>

</div>

<div id="normalization" class="section">
<h3><span class="secno">4.7 </span>Normalization</h3>

<p>Normalization is the process of taking <a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input">JSON-LD input</a> and 
performing a deterministic transformation on that input that results in a 
<a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output">JSON-LD output</a> that any conforming JSON-LD processor would have 
generated given the same input. The problem is a fairly difficult technical 
problem to solve because it requires a directed graph to be ordered into a 
set of nodes and edges in a deterministic way. This is easy to do when all of 
the nodes have unique names, but very difficult to do when some of the nodes 
are not labeled.
</p>

<p>Normalization is useful when comparing two graphs against one another,
when generating a detailed list of differences between two graphs, and
when generating a cryptographic digital signature for information contained 
in a graph or when generating a hash of the information contained in a graph.
</p>

<p>The example below is an un-normalized JSON-LD document:</p>

<pre class="example">
{
   "name": "Manu Sporny",
   "homepage": "http://manu.sporny.org/",
   "@context": 
   {
      "name": "http://xmlns.com/foaf/0.1/name",
      "homepage": "http://xmlns.com/foaf/0.1/homepage",
      "xsd": "http://www.w3.org/2001/XMLSchema#",
      "@coerce": 
      {
         "@iri": ["homepage"]
      }
   }
}</pre>

<p>The example below is the normalized form of the JSON-LD document above:</p>

<p class="note">Whitespace is used below to aid readability. The normalization
algorithm for JSON-LD remove all unnecessary whitespace in the fully 
normalized form.</p>

<pre class="example">
[{
    "@subject": 
    {
        "@iri": "_:c14n0"
    },
    "http://xmlns.com/foaf/0.1/homepage": 
    {
        "@iri": "http://manu.sporny.org/"
    },
    "http://xmlns.com/foaf/0.1/name": "Manu Sporny"
}]</pre>

<p>Notice how all of the <a class="tref internalDFN" title="term" href="#dfn-term">term</a>s have been expanded and sorted in
alphabetical order. Also, notice how the <a class="tref internalDFN" title="subject" href="#dfn-subject">subject</a> has been 
labeled with a <a class="tref internalDFN" title="blank_node_identifier" href="#dfn-blank_node_identifier-7">blank node identifier</a>. Normalization ensures that any arbitrary
graph containing exactly the same information would be normalized to exactly
the same form shown above.</p>

</div>

</div>

<div id="the-application-programming-interface" class="section">

<!-- OddPage -->
<h2><span class="secno">5. </span>The Application Programming Interface</h2>

<p>This API provides a clean mechanism that enables developers to convert 
JSON-LD data into a a variety of output formats that are easier to work with in 
various programming languages. If an API is provided in a programming 
environment, the entire API <em class="rfc2119" title="must">must</em> be implemented.
</p>

<div id="jsonldprocessor" class="section">
<h3><span class="secno">5.1 </span>JSONLDProcessor</h3>
<pre class="idl">
<span class="idlInterface" id="idl-def-JSONLDProcessor">[<span class="extAttr">NoInterfaceObject</span>]
interface <span class="idlInterfaceID">JSONLDProcessor</span> {
<span class="idlMethod">    <span class="idlMethType"><a>object</a></span> <span class="idlMethName"><a href="#widl-JSONLDProcessor-expand-object-object-input-JSONLDProcessorCallback-callback">expand</a></span> (<span class="idlParam">in <span class="idlParamType"><a>object</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam">in optional <span class="idlParamType"><a href="#idl-def-JSONLDProcessorCallback" class="idlType"><code>JSONLDProcessorCallback</code></a>?</span> <span class="idlParamName">callback</span></span>);</span>
<span class="idlMethod">    <span class="idlMethType"><a>object</a></span> <span class="idlMethName"><a href="#widl-JSONLDProcessor-compact-object-object-input-object-context-JSONLDProcessorCallback-callback">compact</a></span> (<span class="idlParam">in <span class="idlParamType"><a>object</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam">in <span class="idlParamType"><a>object</a></span> <span class="idlParamName">context</span></span>, <span class="idlParam">in optional <span class="idlParamType"><a href="#idl-def-JSONLDProcessorCallback" class="idlType"><code>JSONLDProcessorCallback</code></a>?</span> <span class="idlParamName">callback</span></span>);</span>
<span class="idlMethod">    <span class="idlMethType"><a>object</a></span> <span class="idlMethName"><a href="#widl-JSONLDProcessor-frame-object-object-input-object-frame-object-options-JSONLDProcessorCallback-callback">frame</a></span> (<span class="idlParam">in <span class="idlParamType"><a>object</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam">in <span class="idlParamType"><a>object</a></span> <span class="idlParamName">frame</span></span>, <span class="idlParam">in <span class="idlParamType"><a>object</a></span> <span class="idlParamName">options</span></span>, <span class="idlParam">in optional <span class="idlParamType"><a href="#idl-def-JSONLDProcessorCallback" class="idlType"><code>JSONLDProcessorCallback</code></a>?</span> <span class="idlParamName">callback</span></span>);</span>
<span class="idlMethod">    <span class="idlMethType"><a>object</a></span> <span class="idlMethName"><a href="#widl-JSONLDProcessor-normalize-object-object-input-JSONLDProcessorCallback-callback">normalize</a></span> (<span class="idlParam">in <span class="idlParamType"><a>object</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam">in optional <span class="idlParamType"><a href="#idl-def-JSONLDProcessorCallback" class="idlType"><code>JSONLDProcessorCallback</code></a>?</span> <span class="idlParamName">callback</span></span>);</span>
<span class="idlMethod">    <span class="idlMethType"><a>object</a></span> <span class="idlMethName"><a href="#widl-JSONLDProcessor-triples-object-object-input-JSONLDTripleCallback-tripleCallback-JSONLDProcessorCallback-parserCallback">triples</a></span> (<span class="idlParam">in <span class="idlParamType"><a>object</a></span> <span class="idlParamName">input</span></span>, <span class="idlParam">in <span class="idlParamType"><a href="#idl-def-JSONLDTripleCallback" class="idlType"><code>JSONLDTripleCallback</code></a></span> <span class="idlParamName">tripleCallback</span></span>, <span class="idlParam">in optional <span class="idlParamType"><a href="#idl-def-JSONLDProcessorCallback" class="idlType"><code>JSONLDProcessorCallback</code></a>?</span> <span class="idlParamName">parserCallback</span></span>);</span>
};</span>
</pre><div id="methods" class="section"><h4><span class="secno">5.1.1 </span>Methods</h4><dl class="methods"><dt id="widl-JSONLDProcessor-compact-object-object-input-object-context-JSONLDProcessorCallback-callback"><code>compact</code></dt><dd><a href="#compaction">Compacts</a> the given <code>input</code>
    according to the steps in the
    <a href="#compaction-algorithm">Compaction Algorithm</a>. The
    <code>input</code> <em class="rfc2119" title="must">must</em> be copied, compacted and returned if there are
    no errors. If the compaction fails, <code>null</code> <em class="rfc2119" title="must">must</em> be returned.
  
  <table class="parameters"><tr><th>Parameter</th><th>Type</th><th>Nullable</th><th>Optional</th><th>Description</th></tr><tr><td class="prmName">input</td><td class="prmType"><code><a>object</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The JSON-LD object to perform compaction on.</td></tr><tr><td class="prmName">context</td><td class="prmType"><code><a>object</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The base context to use when compacting the <code>input</code>.</td></tr><tr><td class="prmName">callback</td><td class="prmType"><code><a href="#idl-def-JSONLDProcessorCallback" class="idlType"><code>JSONLDProcessorCallback</code></a></code></td><td class="prmNullTrue">✔</td><td class="prmOptTrue">✔</td><td class="prmDesc">A callback that is called whenever a processing error occurs on
       the given <code>input</code>.</td></tr></table><div><em>No exceptions.</em></div><div><em>Return type: </em><code><a>object</a></code></div></dd><dt id="widl-JSONLDProcessor-expand-object-object-input-JSONLDProcessorCallback-callback"><code>expand</code></dt><dd><a href="#expansion">Expands</a> the given <code>input</code>
    according to the steps in the
    <a href="#expansion-algorithm">Expansion Algorithm</a>. The
    <code>input</code> <em class="rfc2119" title="must">must</em> be copied, expanded and returned if there are
    no errors. If the expansion fails, <code>null</code> <em class="rfc2119" title="must">must</em> be returned.
    <div class="issue">How do we generate warning messages during this process?
      For example, what happens when a key that doesn't have a mapping is
      discovered?</div>
  
  <table class="parameters"><tr><th>Parameter</th><th>Type</th><th>Nullable</th><th>Optional</th><th>Description</th></tr><tr><td class="prmName">input</td><td class="prmType"><code><a>object</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The JSON-LD object to copy and perform the expansion upon.</td></tr><tr><td class="prmName">callback</td><td class="prmType"><code><a href="#idl-def-JSONLDProcessorCallback" class="idlType"><code>JSONLDProcessorCallback</code></a></code></td><td class="prmNullTrue">✔</td><td class="prmOptTrue">✔</td><td class="prmDesc">A callback that is called whenever a processing error occurs on
     the <code>input</code>.</td></tr></table><div><em>No exceptions.</em></div><div><em>Return type: </em><code><a>object</a></code></div></dd><dt id="widl-JSONLDProcessor-frame-object-object-input-object-frame-object-options-JSONLDProcessorCallback-callback"><code>frame</code></dt><dd><a href="#framing">Frames</a> the given <code>input</code>
    using the <code>frame</code> according to the steps in the
    <a href="#framing-algorithm">Framing Algorithm</a>. The
    <code>input</code> is used to build the framed output and is returned if 
    there are no errors. Exceptions are thrown if there are errors.
    <div class="issue">Define what the exceptions are. We need to specify
    whether or not we want exceptions thrown, or errors returned to the
    error callback?</div>
  
  <table class="parameters"><tr><th>Parameter</th><th>Type</th><th>Nullable</th><th>Optional</th><th>Description</th></tr><tr><td class="prmName">input</td><td class="prmType"><code><a>object</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The JSON-LD object to perform framing on.</td></tr><tr><td class="prmName">frame</td><td class="prmType"><code><a>object</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The frame to use when re-arranging the data.</td></tr><tr><td class="prmName">options</td><td class="prmType"><code><a>object</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">A set of options that will affect the framing algorithm.</td></tr><tr><td class="prmName">callback</td><td class="prmType"><code><a href="#idl-def-JSONLDProcessorCallback" class="idlType"><code>JSONLDProcessorCallback</code></a></code></td><td class="prmNullTrue">✔</td><td class="prmOptTrue">✔</td><td class="prmDesc">A callback that is called whenever a processing error occurs on
     the given <code>input</code>.</td></tr></table><div><em>No exceptions.</em></div><div><em>Return type: </em><code><a>object</a></code></div></dd><dt id="widl-JSONLDProcessor-normalize-object-object-input-JSONLDProcessorCallback-callback"><code>normalize</code></dt><dd><a href="#normalization">Normalizes</a> the given <code>input</code>
    according to the steps in the
    <a href="#normalization-algorithm">Normalization Algorithm</a>. The
    <code>input</code> <em class="rfc2119" title="must">must</em> be copied, normalized and returned if there are
    no errors. If the compaction fails, <code>null</code> <em class="rfc2119" title="must">must</em> be returned.
  
  <table class="parameters"><tr><th>Parameter</th><th>Type</th><th>Nullable</th><th>Optional</th><th>Description</th></tr><tr><td class="prmName">input</td><td class="prmType"><code><a>object</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The JSON-LD object to perform normalization upon.</td></tr><tr><td class="prmName">callback</td><td class="prmType"><code><a href="#idl-def-JSONLDProcessorCallback" class="idlType"><code>JSONLDProcessorCallback</code></a></code></td><td class="prmNullTrue">✔</td><td class="prmOptTrue">✔</td><td class="prmDesc">A callback that is called whenever a processing error occurs on
     the given JSON-LD string.</td></tr></table><div><em>No exceptions.</em></div><div><em>Return type: </em><code><a>object</a></code></div></dd><dt id="widl-JSONLDProcessor-triples-object-object-input-JSONLDTripleCallback-tripleCallback-JSONLDProcessorCallback-parserCallback"><code>triples</code></dt><dd>Processes the <code>input</code> according to the 
    <a href="#rdf-conversion-algorithm">RDF Conversion Algorithm</a>, calling
    the provided <code>tripleCallback</code> for each triple generated.
  
  <table class="parameters"><tr><th>Parameter</th><th>Type</th><th>Nullable</th><th>Optional</th><th>Description</th></tr><tr><td class="prmName">input</td><td class="prmType"><code><a>object</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The JSON-LD object to process when outputting triples.</td></tr><tr><td class="prmName">tripleCallback</td><td class="prmType"><code><a href="#idl-def-JSONLDTripleCallback" class="idlType"><code>JSONLDTripleCallback</code></a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">A callback that is called whenever a processing error occurs on
     the given <code>input</code>.
     <div class="issue">This callback should be aligned with the 
       RDF API.</div></td></tr><tr><td class="prmName">parserCallback</td><td class="prmType"><code><a href="#idl-def-JSONLDProcessorCallback" class="idlType"><code>JSONLDProcessorCallback</code></a></code></td><td class="prmNullTrue">✔</td><td class="prmOptTrue">✔</td><td class="prmDesc">A callback that is called whenever a processing error occurs on
     the given <code>input</code>.</td></tr></table><div><em>No exceptions.</em></div><div><em>Return type: </em><code><a>object</a></code></div></dd></dl></div>
</div>

<div id="jsonldprocessorcallback" class="section">
<h3><span class="secno">5.2 </span>JSONLDProcessorCallback</h3>
<p>The JSONLDProcessorCallback is called whenever a processing error occurs 
while processing the <a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input">JSON-LD input</a>.</p>

<pre class="idl">
<span class="idlInterface" id="idl-def-JSONLDProcessorCallback">[<span class="extAttr">NoInterfaceObject Callback</span>]
interface <span class="idlInterfaceID">JSONLDProcessorCallback</span> {
<span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-JSONLDProcessorCallback-error-void-DOMString-error">error</a></span> (<span class="idlParam">in <span class="idlParamType"><a>DOMString</a></span> <span class="idlParamName">error</span></span>);</span>
};</span>
</pre><div id="methods-1" class="section"><h4><span class="secno">5.2.1 </span>Methods</h4><dl class="methods"><dt id="widl-JSONLDProcessorCallback-error-void-DOMString-error"><code>error</code></dt><dd>This callback is invoked whenever an error occurs during processing.
  
  <table class="parameters"><tr><th>Parameter</th><th>Type</th><th>Nullable</th><th>Optional</th><th>Description</th></tr><tr><td class="prmName">error</td><td class="prmType"><code><a>DOMString</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">A descriptive error string returned by the processor.</td></tr></table><div><em>No exceptions.</em></div><div><em>Return type: </em><code><a>void</a></code></div></dd></dl></div>
</div>

<div id="jsonldtriplecallback" class="section">
<h3><span class="secno">5.3 </span>JSONLDTripleCallback</h3>
<p>The JSONLDTripleCallback is called whenever the processor generates a
triple during the <code>triple()</code> call.</p>

<pre class="idl">
<span class="idlInterface" id="idl-def-JSONLDTripleCallback">[<span class="extAttr">NoInterfaceObject Callback</span>]
interface <span class="idlInterfaceID">JSONLDTripleCallback</span> {
<span class="idlMethod">    <span class="idlMethType"><a>void</a></span> <span class="idlMethName"><a href="#widl-JSONLDTripleCallback-triple-void-DOMString-subject-DOMString-property-DOMString-objectType-DOMString-object-DOMString-datatype-DOMString-language">triple</a></span> (<span class="idlParam">in <span class="idlParamType"><a>DOMString</a></span> <span class="idlParamName">subject</span></span>, <span class="idlParam">in <span class="idlParamType"><a>DOMString</a></span> <span class="idlParamName">property</span></span>, <span class="idlParam">in <span class="idlParamType"><a>DOMString</a></span> <span class="idlParamName">objectType</span></span>, <span class="idlParam">in <span class="idlParamType"><a>DOMString</a></span> <span class="idlParamName">object</span></span>, <span class="idlParam">in <span class="idlParamType"><a>DOMString</a>?</span> <span class="idlParamName">datatype</span></span>, <span class="idlParam">in <span class="idlParamType"><a>DOMString</a>?</span> <span class="idlParamName">language</span></span>);</span>
};</span>
</pre><div id="methods-2" class="section"><h4><span class="secno">5.3.1 </span>Methods</h4><dl class="methods"><dt id="widl-JSONLDTripleCallback-triple-void-DOMString-subject-DOMString-property-DOMString-objectType-DOMString-object-DOMString-datatype-DOMString-language"><code>triple</code></dt><dd>This callback is invoked whenever a triple is generated by the processor.
  
  <table class="parameters"><tr><th>Parameter</th><th>Type</th><th>Nullable</th><th>Optional</th><th>Description</th></tr><tr><td class="prmName">subject</td><td class="prmType"><code><a>DOMString</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The subject IRI that is associated with the triple.</td></tr><tr><td class="prmName">property</td><td class="prmType"><code><a>DOMString</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The property IRI that is associated with the triple.</td></tr><tr><td class="prmName">objectType</td><td class="prmType"><code><a>DOMString</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The type of object that is associated with the triple. Valid values
       are <code>IRI</code> and <code>literal</code>.</td></tr><tr><td class="prmName">object</td><td class="prmType"><code><a>DOMString</a></code></td><td class="prmNullFalse">✘</td><td class="prmOptFalse">✘</td><td class="prmDesc">The object value associated with the subject and the property.</td></tr><tr><td class="prmName">datatype</td><td class="prmType"><code><a>DOMString</a></code></td><td class="prmNullTrue">✔</td><td class="prmOptFalse">✘</td><td class="prmDesc">The datatype associated with the object.</td></tr><tr><td class="prmName">language</td><td class="prmType"><code><a>DOMString</a></code></td><td class="prmNullTrue">✔</td><td class="prmOptFalse">✘</td><td class="prmDesc">The language associated with the object in BCP47 format.</td></tr></table><div><em>No exceptions.</em></div><div><em>Return type: </em><code><a>void</a></code></div></dd></dl></div>
</div>


</div>

<div id="algorithms" class="section">

<!-- OddPage -->
<h2><span class="secno">6. </span>Algorithms</h2>

<p>All algorithms described in this section are intended to operate on
language-native data structures. That is, the serialization to a text-based
JSON document isn't required as input or output to any of these algorithms and 
language-native data structures <em class="rfc2119" title="must">must</em> be used where applicable.</p>

<div id="syntax-tokens-and-keywords" class="section">
  <h3><span class="secno">6.1 </span>Syntax Tokens and Keywords</h3>
  
  <p>JSON-LD specifies a number of syntax tokens and keywords that are using
  in all algorithms described in this section:</p>
  
  <dl>
  <dt><code>@context</code></dt><dd>Used to set the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a>.</dd>
  <dt><code>@base</code></dt><dd>Used to set the base IRI for all object IRIs affected  by the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>.</dd>
  <dt><code>@vocab</code></dt><dd>Used to set the base IRI for all property IRIs affected by the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>.</dd>
  <dt><code>@coerce</code></dt><dd>Used to specify type coercion rules.</dd>
  <dt><code>@literal</code></dt><dd>Used to specify a literal value.</dd>
  <dt><code>@iri</code></dt><dd>Used to specify an IRI value.</dd>
  <dt><code>@language</code></dt><dd>Used to specify the language for a literal.</dd>
  <dt><code>@datatype</code></dt><dd>Used to specify the datatype for a literal.</dd>
  <dt><code>:</code></dt><dd>The separator for <a class="tref internalDFN" title="CURIE" href="#dfn-curie">CURIE</a>s when used in JSON keys or JSON values.</dd>
  <dt><code>@subject</code></dt><dd>Sets the active subjects.</dd>
  <dt><code>@type</code></dt><dd>Used to set the type of the active subjects.</dd>
  </dl>
</div>

<div id="algorithm-terms" class="section">
  <h3><span class="secno">6.2 </span>Algorithm Terms</h3>
  <dl>
    <dt><dfn title="initial_context" id="dfn-initial_context">initial context</dfn></dt>
    <dd>
      a context that is specified to the algorithm before processing begins.
    </dd>
    <dt><dfn title="active_subject" id="dfn-active_subject">active subject</dfn></dt>
    <dd>
      the currently active subject that the processor should use when 
      processing.
    </dd>
    <dt><dfn title="active_property" id="dfn-active_property">active property</dfn></dt>
    <dd>
      the currently active property that the processor should use when 
      processing.
    </dd>
    <dt><dfn title="active_object" id="dfn-active_object">active object</dfn></dt>
    <dd>
      the currently active object that the processor should use when
      processing.
    </dd>
    <dt><dfn title="active_context" id="dfn-active_context">active context</dfn></dt>
    <dd>
      a context that is used to resolve <a class="tref internalDFN" title="CURIE" href="#dfn-curie">CURIE</a>s while the processing
      algorithm is running. The <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> is the context 
      contained within the <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a>.
    </dd>
    <dt><dfn title="local_context" id="dfn-local_context">local context</dfn></dt>
    <dd>
      a context that is specified within a <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a>,
      specified via the <code>@context</code> keyword.
    </dd>
    <dt><dfn title="processor_state" id="dfn-processor_state">processor state</dfn></dt>
    <dd>
      the <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a>, which includes the <a class="tref" title="active__context">active
      context</a>, <a class="tref" title="current_subject">current subject</a>, and 
      <a class="tref" title="current_property">current property</a>. The <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a> is managed
      as a stack with elements from the previous <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a>
      copied into a new <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a> when entering a new 
      <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a>.
    </dd>
    <dt><dfn title="JSON-LD_input" id="dfn-json-ld_input">JSON-LD input</dfn></dt>
    <dd>
      The JSON-LD data structure that is provided as input to the algorithm.
    </dd>
    <dt><dfn title="JSON-LD_output" id="dfn-json-ld_output">JSON-LD output</dfn></dt>
    <dd>
      The JSON-LD data structure that is produced as output by the algorithm.
    </dd>

  </dl>
</div>

<div id="context-1" class="section">
  <h3 id="context"><span class="secno">6.3 </span>Context</h3>
  <p>
    Processing of JSON-LD data structure is managed recursively.
    During processing, each rule is applied using information provided by the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>.
    Processing begins by pushing a new <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a> onto the <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a> stack and
    initializing the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> with the <a class="tref internalDFN" title="initial_context" href="#dfn-initial_context">initial context</a>. If a <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> is encountered,
    information from the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> is merged into the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>.
  </p>
  <p>
    The <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> is used for expanding keys and values of a <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a> (or elements
    of a list (see <span a="#list-processing">List Processing</span>)).
  </p>
  <p>
    A <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> is identified within a <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a> having a key of
    <code>@context</code> with <a class="tref internalDFN" title="string" href="#dfn-string">string</a> or a <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a> value. When processing a <a class="tref" title="local__context">local
    context</a>, special processing rules apply:
  </p>
  <ol class="algorithm">
    <li>Create a new, empty <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a>.</li>
    <li>
      If the value is a simple <a class="tref internalDFN" title="string" href="#dfn-string">string</a>, it <em class="rfc2119" title="must">must</em> have a lexical form of IRI and used to initialize
      a new JSON document which replaces the value for subsequent processing.
    </li>
    <li>If the value is a <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a>, perform the following steps:
      <ol class="algorithm">
        <li>
          If the <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a> has a <code>@base</code> key, it <em class="rfc2119" title="must">must</em> have a value of a simple
          <a class="tref internalDFN" title="string" href="#dfn-string">string</a> with the lexical form of an absolute IRI. Add the base mapping to the <a class="tref" title="local__context">local
          context</a>. <p class="issue">Turtle allows @base to be relative. If we did this, we
          would have to add <a href="#iri-expansion">IRI Expansion</a>.</p>
        </li>
        <li>
          If the <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a> has a <code>@vocab</code> key, it <em class="rfc2119" title="must">must</em> have a value of a simple
          <a class="tref internalDFN" title="string" href="#dfn-string">string</a> with the lexical form of an absolute IRI. Add the vocabulary mapping to the
          <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> after performing <a href="#iri-expansion">IRI Expansion</a> on
          the associated value.
        </li>
        <li>
          If the <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a> has a <code>@coerce</code> key, it <em class="rfc2119" title="must">must</em> have a value of a
          <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a>. Add the <code>@coerce</code> mapping to the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a>
          performing <a href="#iri-expansion">IRI Expansion</a> on the associated value(s).
        </li>
        <li>
          Otherwise, the key <em class="rfc2119" title="must">must</em> have the lexical form of <cite><a href="http://www.w3.org/TR/2009/REC-xml-names-20091208/#NT-NCName">NCName</a></cite> and
          <em class="rfc2119" title="must">must</em> have the value of a simple <a class="tref internalDFN" title="string" href="#dfn-string">string</a> with the lexical form of IRI. Merge the key-value
          pair into the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a>.
        </li>
      </ol>
    </li>
    <li>
      Merge the of <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a>'s <code>@coerce</code> mapping into  the
      <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>'s <code>@coerce</code> mapping as described <a href="#coerce">below</a>.
    </li>
    <li>
      Merge all entries other than the <code>@coerce</code> mapping from the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a>to the
      <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> overwriting any duplicate values.
    </li>
  </ol>
  
  <div id="coerce" class="section">
    <h4><span class="secno">6.3.1 </span>Coerce</h4>
    <p>
      Map each key-value pair in the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a>'s
      <code>@coerce</code> mapping into the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>'s
      <code>@coerce</code> mapping, overwriting any duplicate values in 
      the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>'s <code>@coerce</code> mapping.
      The <code>@coerce</code> mapping has either a single <a class="tref internalDFN" title="CURIE" href="#dfn-curie">CURIE</a> or an
      <a class="tref internalDFN" title="array" href="#dfn-array">array</a> of CURIEs. When merging with an existing mapping in the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>,
      map all CURIE values to <a class="tref internalDFN" title="array" href="#dfn-array">array</a> form and replace with the union of the value from
      the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> and the value of the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>. If the result is an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>
      with a single CURIE, the processor <em class="rfc2119" title="may">may</em> represent this as a string value.
    </p>
  </div>

  <div id="initial-context" class="section">
    <h4><span class="secno">6.3.2 </span>Initial Context</h4>
    <p>The <a class="tref internalDFN" title="initial_context" href="#dfn-initial_context">initial context</a> is initialized as follows:</p>
    <ul>
      <li>
        <code>@base</code> is set using <cite><href="http: www.ietf.org="" rfc="" rfc2396.txt"="">section 5.1 Establishing a
        Base URI</href="http:></cite> of [<cite><a class="bibref" rel="biblioentry" href="#bib-RFC3986">RFC3986</a></cite>]. Processors <em class="rfc2119" title="may">may</em> provide a means
        of setting the base IRI programatically.
      </li>
      <li><code>@coerce</code> is set with a single mapping from <code>@iri</code> to <code>@type</code>.</li>
    </ul>
    <pre class="example">
{
    "@base": <span class="diff">document-location</span>,
    "@context": {
      "@iri": "@type"
    }
}</pre>
  </div>
</div>

<div id="iri-expansion" class="section">
  <h3><span class="secno">6.4 </span>IRI Expansion</h3>
  <p>Keys and some values are evaluated to produce an IRI. This section defines an algorithm for
    transforming a value representing an IRI into an actual IRI.</p>
  <p>IRIs may be represented as an explicit string, or as a <a class="tref internalDFN" title="CURIE" href="#dfn-curie">CURIE</a>, as a value relative to <code>@base</code>
    or <code>@vocab</code>.</p>
  <p>The algorithm for generating an IRI is:
    </p><ol class="algorithm">
      <li>Split the value into a <em>prefix</em> and <em>suffix</em> from the first occurrence of ':'.</li>
      <li>If the prefix is a '_' (underscore), the IRI is unchanged.</li>
      <li>If the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> contains a mapping for <em>prefix</em>, generate an IRI
        by prepending the mapped prefix to the (possibly empty) suffix using textual concatenation. Note that an empty
        suffix and no suffix (meaning the value contains no ':' string at all) are treated equivalently.</li>
      <li>If the IRI being processed is for a property (i.e., a key value in a <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a>, or a
        value in a <code>@coerce</code> mapping) and the active context has a <code>@vocab</code> mapping,
        join the mapped value to the suffix using textual concatenation.</li>
      <li>If the IRI being processed is for a subject or object (i.e., not a property) and the active context has a <code>@base</code> mapping,
        join the mapped value to the suffix using the method described in [<cite><a class="bibref" rel="biblioentry" href="#bib-RFC3986">RFC3986</a></cite>].</li>
      <li>Otherwise, use the value directly as an IRI.</li>
    </ol>
  <p></p>
</div>

<div id="iri-compaction" class="section">
  <h3><span class="secno">6.5 </span>IRI Compaction</h3>
  <p>Some keys and values are expressed using IRIs. This section defines an 
    algorithm for transforming an IRI to a compact IRI using the
    <a class="tref internalDFN" title="term" href="#dfn-term">term</a>s and <a class="tref internalDFN" title="prefix" href="#dfn-prefix">prefix</a>es specified in the 
    <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a>.</p>

  <p>The algorithm for generating a compacted IRI is:
    </p><ol class="algorithm">
      <li>Search every key-value pair in the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> for
        a <a class="tref internalDFN" title="term" href="#dfn-term">term</a> that is a complete match 
        against the IRI. If a complete match is found, the resulting compacted
        IRI is the <a class="tref internalDFN" title="term" href="#dfn-term">term</a> associated with the IRI in the 
        <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>.</li>
      <li>If a complete match is not found, search for a partial match from
        the beginning of the IRI. For all matches that are found, the resulting
        compacted IRI is the <a class="tref internalDFN" title="prefix" href="#dfn-prefix">prefix</a> associated with the partially
        matched IRI in the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> concatenated with a 
        colon (:) character and the unmatched part of the string. If there is
        more than one compacted IRI produced, the final value is the 
        lexicographically least value of the entire set of compacted IRIs.</li>
    </ol>
  <p></p>
</div>

<div id="value-expansion" class="section">
  <h3><span class="secno">6.6 </span>Value Expansion</h3>
  <p>Some values in JSON-LD can be expressed in a compact form. These values
    are required to be expanded at times when processing JSON-LD documents.
  </p>

  <p>The algorithm for expanding a value is:
    </p><ol class="algorithm">
      <li>If the key that is associated with the value has an associated
        coercion entry in the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a>, the resulting
        expansion is an object populated according to the following steps:
        <ol class="algorithm">
          <li>If the coercion target is <code>@iri</code>, expand the value
            by adding a new key-value pair where the key is <code>@iri</code>
            and the value is the expanded IRI according to the
            <a href="#iri-expansion">IRI Expansion</a> rules.</li>
          <li>If the coercion target is a typed literal, expand the value
            by adding two new key-value pairs. The first key-value pair 
            will be <code>@literal</code> and the unexpanded value. The second
            key-value pair will be <code>@datatype</code> and the associated
            coercion datatype expanded according to the
            <a href="#iri-expansion">IRI Expansion</a> rules.</li>
        </ol>
      </li>
    </ol>
  <p></p>
</div>

<div id="value-compaction" class="section">
  <h3><span class="secno">6.7 </span>Value Compaction</h3>
  <p>Some values, such as IRIs and typed literals, may be expressed in an
    expanded form in JSON-LD. These values are required to be compacted at 
    times when processing JSON-LD documents.
  </p>

  <p>The algorithm for compacting a value is:
    </p><ol class="algorithm">
      <li>If the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> contains a coercion target for the
        key that is associated with the value, compact the value using the
        following steps:
        <ol class="algorithm">
          <li>If the coercion target is an <code>@iri</code>, the compacted
            value is the value associated with the <code>@iri</code> key,
            processed according to the 
            <a href="#iri-compaction">IRI Compaction</a> steps.</li>
          <li>If the coercion target is a typed literal, the compacted
            value is the value associated with the <code>@literal</code> key.
          </li>
          <li>Otherwise, the value is not modified.</li>
        </ol>
      </li>
    </ol>
  <p></p>
</div>

<div id="expansion-1" class="section">
<h3><span class="secno">6.8 </span>Expansion</h3>

<p class="issue">This algorithm is a work in progress, do not implement it.</p>

<p>As stated previously, expansion is the process of taking a JSON-LD 
input and expanding all IRIs and typed literals to their fully-expanded form. 
The output will not contain a single context declaration and will have all IRIs 
and typed literals fully expanded.
</p>

<div id="expansion-algorithm" class="section">
<h4><span class="secno">6.8.1 </span>Expansion Algorithm</h4>

<ol class="algorithm">
  <li>If the top-level item in the <a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input">JSON-LD input</a> is an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, 
  process each item in the <a class="tref internalDFN" title="array" href="#dfn-array">array</a> recursively using this algorithm.</li>
  <li>If the top-level item in the <a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input">JSON-LD input</a> is an object, 
  update the <a class="tref internalDFN" title="local_context" href="#dfn-local_context">local context</a> according to the steps outlined in
  the <a href="#context">context</a> section. Process each key, expanding 
  the key according to the <a href="#iri-expansion">IRI Expansion</a> rules.</li>
  <ol class="algorithm">
    <li>Process each value associated with each key
      <ol class="algorithm">
        <li>If the value is an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, process each item in the <a class="tref internalDFN" title="array" href="#dfn-array">array</a> 
        recursively using this algorithm.</li>
        <li>If the value is an object, process the object recursively
        using this algorithm.</li>
        <li>Otherwise, check to see the associated key has an associated 
        coercion rule. If the value should be coerced, expand the value 
        according to the <a href="#value-expansion">Value Expansion</a> rules. 
        If the value does not need to be coerced, leave the value as-is.
        </li>
      </ol>
    </li><li>Remove the context from the object</li>
  </ol>
</ol>
</div>

</div>

<div id="compaction-1" class="section">
<h3><span class="secno">6.9 </span>Compaction</h3>

<p class="issue">This algorithm is a work in progress, do not implement it.</p>

<p>As stated previously, compaction is the process of taking a JSON-LD 
input and compacting all IRIs using a given context. The output
will contain a single top-level context declaration and will only use
<a class="tref internalDFN" title="term" href="#dfn-term">term</a>s and <a class="tref internalDFN" title="prefix" href="#dfn-prefix">prefix</a>es and will ensure that all
typed literals are fully compacted.
</p>

<div id="compaction-algorithm" class="section">
<h4><span class="secno">6.9.1 </span>Compaction Algorithm</h4>

<ol class="algorithm">
  <li>Perform the <a href="#expansion-algorithm">Expansion Algorithm</a> on 
  the <a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input">JSON-LD input</a>.</li>
  <li>If the top-level item is an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, process each item in the <a class="tref internalDFN" title="array" href="#dfn-array">array</a> 
    recursively, starting at this step.
  </li><li>If the top-level item is an object, compress each key using the steps
    defined in <a href="#iri-compaction">IRI Compaction</a> and compress each
    value using the steps defined in 
    <a href="#value-compaction">Value Compaction</a></li>
  
</ol>
</div>

</div>


<div id="framing-1" class="section">
<h3><span class="secno">6.10 </span>Framing</h3>

<p class="issue">This algorithm is a work in progress, do not implement it.</p>

<p>A JSON-LD document is a representation of a directed graph. A single
directed graph can have many different serializations, each expressing
exactly the same information. Developers typically don't work directly with
graphs, but rather, prefer trees when dealing with JSON. While mapping a graph 
to a tree can be done, the layout of the end result must be specified in 
advance. This section defines an algorithm for mapping a graph to 
a tree given a <a class="tref internalDFN" title="frame" href="#dfn-frame">frame</a>.
</p>

<div id="framing-algorithm-terms" class="section">
<h4><span class="secno">6.10.1 </span>Framing Algorithm Terms</h4>
 <dl>
   <dt><dfn title="input_frame" id="dfn-input_frame">input frame</dfn></dt>
   <dd>
     the initial <a class="tref internalDFN" title="frame" href="#dfn-frame">frame</a> provided to the framing algorithm.
   </dd>
   <dt><dfn title="framing_context" id="dfn-framing_context">framing context</dfn></dt>
   <dd>
     a context containing the <a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag">object embed flag</a>, the
     <a class="tref internalDFN" title="explicit_inclusion_flag" href="#dfn-explicit_inclusion_flag">explicit inclusion flag</a> and the 
     <a class="tref" title="omit_default_flag">omit default flag</a>.
   </dd>
   <dt><dfn title="object_embed_flag" id="dfn-object_embed_flag">object embed flag</dfn></dt>
   <dd>
     a flag specifying that objects should be directly embedded in the output,
     instead of being referred to by their IRI.
   </dd>
   <dt><dfn title="explicit_inclusion_flag" id="dfn-explicit_inclusion_flag">explicit inclusion flag</dfn></dt>
   <dd>
     a flag specifying that for properties to be included in the output, they
     must be explicitly declared in the <a class="tref internalDFN" title="framing_context" href="#dfn-framing_context">framing context</a>.
   </dd>
   <dt><dfn title="omit_missing_properties_flag" id="dfn-omit_missing_properties_flag">omit missing properties flag</dfn></dt>
   <dd>
     a flag specifying that properties that are missing from the 
     <a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input">JSON-LD input</a> should be omitted from the output.
   </dd>
   <dt><dfn title="match_limit" id="dfn-match_limit">match limit</dfn></dt>
   <dd>
     A value specifying the maximum number of matches to accept when building
     arrays of values during the framing algorithm. A value of -1 specifies
     that there is no match limit.
   </dd>
   <dt><dfn title="map_of_embedded_subjects" id="dfn-map_of_embedded_subjects">map of embedded subjects</dfn></dt>
   <dd>
     A map that tracks if a subject has been embedded in the output of the
     <a href="#framing-algorithm">Framing Algorithm</a>.
   </dd>
 </dl>
</div>

<div id="framing-algorithm" class="section">
<h4><span class="secno">6.10.2 </span>Framing Algorithm</h4>

<p>The framing algorithm takes <a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input">JSON-LD input</a> that has been 
normalized according to the 
<a href="#normalization-algorithm">Normalization Algorithm</a> 
(<strong>normalized input</strong>), an 
<a class="tref internalDFN" title="input_frame" href="#dfn-input_frame">input frame</a> that has been expanded according to the
<a href="#expansion-algorithm">Expansion Algorithm</a> 
(<strong>expanded frame</strong>), and a number of options and produces
<a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output">JSON-LD output</a>. The following series of steps is the recursive
portion of the framing algorithm:
</p>

<ol class="algorithm">
  <li>Initialize the <a class="tref internalDFN" title="framing_context" href="#dfn-framing_context">framing context</a> by setting the
   <a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag">object embed flag</a>, clearing the 
   <a class="tref internalDFN" title="explicit_inclusion_flag" href="#dfn-explicit_inclusion_flag">explicit inclusion flag</a>, and clearing the
   <a class="tref internalDFN" title="omit_missing_properties_flag" href="#dfn-omit_missing_properties_flag">omit missing properties flag</a>. Override these values
   based on input options provided to the algorithm by the application.
  </li>
  <li>Generate a <dfn title="list_of_frames" id="dfn-list_of_frames">list of frames</dfn> by processing the 
    <strong>expanded frame</strong>:
    <ol class="algorithm">
      <li>If the <strong>expanded frame</strong> is not an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, set 
        <a class="tref internalDFN" title="match_limit" href="#dfn-match_limit">match limit</a> to 1, place the 
        <strong>expanded frame</strong> into the <a class="tref internalDFN" title="list_of_frames" href="#dfn-list_of_frames">list of frames</a>,
        and set the <a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output">JSON-LD output</a> to <code>null</code>.</li>
      <li>If the <strong>expanded frame</strong> is an empty <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, place an
        empty object into the <a class="tref internalDFN" title="list_of_frames" href="#dfn-list_of_frames">list of frames</a>,
        set the <a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output">JSON-LD output</a> to an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, and set
        <a class="tref internalDFN" title="match_limit" href="#dfn-match_limit">match limit</a> to -1.</li>
      <li>If the <strong>expanded frame</strong> is a non-empty <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, add
        each item in the <strong>expanded frame</strong> into the 
        <a class="tref internalDFN" title="list_of_frames" href="#dfn-list_of_frames">list of frames</a>, set the <a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output">JSON-LD output</a> to an
        <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, and set <a class="tref internalDFN" title="match_limit" href="#dfn-match_limit">match limit</a> to -1.</li>
    </ol></li>
  <li>Create a <dfn title="match_array" id="dfn-match_array">match array</dfn> for each <strong>expanded frame</strong> 
    in the <a class="tref internalDFN" title="list_of_frames" href="#dfn-list_of_frames">list of frames</a> halting when either the 
    <a class="tref internalDFN" title="match_limit" href="#dfn-match_limit">match limit</a> is zero or the end of the 
    <a class="tref internalDFN" title="list_of_frames" href="#dfn-list_of_frames">list of frames</a> is reached. If an 
    <strong>expanded frame</strong> is 
    not an object, the processor <em class="rfc2119" title="must">must</em> throw a <code>Invalid Frame Format</code> 
    exception. Add each matching item from the <strong>normalized input</strong>
    to the <a class="tref" title="matches_array">matches array</a> and decrement the 
    <a class="tref internalDFN" title="match_limit" href="#dfn-match_limit">match limit</a> by 1 if:
    <ol class="algorithm">
       <li>The <strong>expanded frame</strong> has an <code>rdf:type</code> 
         that exists in the item's list of <code>rdf:type</code>s. Note: 
         the <code>rdf:type</code> can be an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>, but only one value needs 
         to be in common between the item and the 
         <strong>expanded frame</strong> for a match.</li>
       <li>The <strong>expanded frame</strong> does not have an 
         <code>rdf:type</code> property, but every property in the 
         <strong>expanded frame</strong> exists in the item.</li>
    </ol></li>
  <li>Process each item in the <a class="tref internalDFN" title="match_array" href="#dfn-match_array">match array</a> with its associated
    <dfn title="match_frame" id="dfn-match_frame">match frame</dfn>:
    <ol class="algorithm">
      <li>If the <a class="tref internalDFN" title="match_frame" href="#dfn-match_frame">match frame</a> contains an <code>@embed</code>
        keyword, set the <a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag">object embed flag</a> to its value. 
        If the <a class="tref internalDFN" title="match_frame" href="#dfn-match_frame">match frame</a> contains an <code>@explicit</code>
        keyword, set the <a class="tref internalDFN" title="explicit_inclusion_flag" href="#dfn-explicit_inclusion_flag">explicit inclusion flag</a> to its value. 
        Note: if the keyword exists, but the value is neither
        <code>true</code> or <code>false</code>, set the associated flag to 
        <code>true</code>.</li>
      <li>If the <a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag">object embed flag</a> is cleared and the item has
        the <code>@subject</code> property, replace the item with the value
        of the <code>@subject</code> property.</li>
      <li>If the <a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag">object embed flag</a> is set and the item has
        the <code>@subject</code> property, and its IRI is in the 
        <a class="tref internalDFN" title="map_of_embedded_subjects" href="#dfn-map_of_embedded_subjects">map of embedded subjects</a>, throw a
        <code>Duplicate Embed</code> exception.</li>
      <li>If the <a class="tref internalDFN" title="object_embed_flag" href="#dfn-object_embed_flag">object embed flag</a> is set and the item has
        the <code>@subject</code> property and its IRI is not in the
        <a class="tref internalDFN" title="map_of_embedded_subjects" href="#dfn-map_of_embedded_subjects">map of embedded subjects</a>:
        <ol class="algorithm">
          <li>If the <a class="tref internalDFN" title="explicit_inclusion_flag" href="#dfn-explicit_inclusion_flag">explicit inclusion flag</a> is set, 
            then delete any key from the item that does not exist in the
            <a class="tref internalDFN" title="match_frame" href="#dfn-match_frame">match frame</a>, except <code>@subject</code>.</li>
          <li>For each key in the <a class="tref internalDFN" title="match_frame" href="#dfn-match_frame">match frame</a>, except for
            keywords and <code>rdf:type</code>:
          <ol class="algorithm">
            <li>If the key is in the item, then build a new 
              <dfn title="recursion_input_list" id="dfn-recursion_input_list">recursion input list</dfn> using the object or objects 
              associated with the key. If any object contains an
              <code>@iri</code> value that exists in the 
              <a class="tref" title="normalized_input">normalized input</a>, replace the object in the
              <a class="tref" title="recusion_input_list">recusion input list</a> with a new object containing
              the <code>@subject</code> key where the value is the value of
              the <code>@iri</code>, and all of the other key-value pairs for
              that subject. Set the <dfn title="recursion_match_frame" id="dfn-recursion_match_frame">recursion match frame</dfn> to the
              value associated with the <a class="tref internalDFN" title="match_frame" href="#dfn-match_frame">match frame</a>'s key. Replace
              the value associated with the key by recursively calling this
              algorithm using <a class="tref internalDFN" title="recursion_input_list" href="#dfn-recursion_input_list">recursion input list</a>,
              <a class="tref internalDFN" title="recursion_match_frame" href="#dfn-recursion_match_frame">recursion match frame</a> as input.</li>
            <li>If the key is not in the item, add the key to the item and
              set the associated value to an empty array if the
              <a class="tref internalDFN" title="match_frame" href="#dfn-match_frame">match frame</a> key's value is an array 
              or <code>null</code> otherwise.</li>
            <li>If value associated with the item's key is <code>null</code>,
              process the <a class="tref internalDFN" title="omit_missing_properties_flag" href="#dfn-omit_missing_properties_flag">omit missing properties flag</a>:
              <ol class="algorithm">
                <li>If the value associated with the key in the 
                  <a class="tref internalDFN" title="match_frame" href="#dfn-match_frame">match frame</a> is an array, use the first frame 
                  from the array as the <dfn title="property_frame" id="dfn-property_frame">property frame</dfn>, otherwise
                  set the <a class="tref internalDFN" title="property_frame" href="#dfn-property_frame">property frame</a> to an empty object.</li>
                <li>If the <a class="tref internalDFN" title="property_frame" href="#dfn-property_frame">property frame</a> contains an
                <code>@omitDefault</code> keyword, set the
                <a class="tref internalDFN" title="omit_missing_properties_flag" href="#dfn-omit_missing_properties_flag">omit missing properties flag</a> to its value.
                Note: if the keyword exists, but the value is neither
                <code>true</code> or <code>false</code>, set the associated
                flag to <code>true</code>.</li>
                <li>If the <a class="tref internalDFN" title="omit_missing_properties_flag" href="#dfn-omit_missing_properties_flag">omit missing properties flag</a> is set,
                  delete the key in the item. Otherwise, if the
                  <code>@default</code> keyword is set in the 
                  <a class="tref internalDFN" title="property_frame" href="#dfn-property_frame">property frame</a> set the item's value to the value
                  of <code>@default</code>.</li>
              </ol></li>
          </ol></li>
        </ol>
      </li><li>If the <a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output">JSON-LD output</a> is <code>null</code> set it to
        the item, otherwise, append the item to the
        <a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output">JSON-LD output</a>.
    </li></ol>
  </li><li>Return the <a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output">JSON-LD output</a>.</li>
</ol>  

The final, non-recursive step of the framing algorithm requires the 
<a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output">JSON-LD output</a> to be compacted according to the 
<a href="#compaction-algorithm">Compaction Algorithm</a> by using the 
context provided in the <a class="tref internalDFN" title="input_frame" href="#dfn-input_frame">input frame</a>. The resulting value is the
final output of the compaction algorithm and is what should be returned to the
application.

</div>

</div>

<div id="normalization-1" class="section">
<h3><span class="secno">6.11 </span>Normalization</h3>

<p class="issue">This algorithm is a work in progress, do not implement it.</p>

<p>Normalization is the process of taking <a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input">JSON-LD input</a> and 
performing a deterministic transformation on that input that results in all
aspects of the graph being fully expanded and named in the 
<a class="tref internalDFN" title="JSON-LD_output" href="#dfn-json-ld_output">JSON-LD output</a>. The normalized output is generated in such a way 
that any conforming JSON-LD processor will generate identical output 
given the same input. The problem is a fairly difficult technical 
problem to solve because it requires a directed graph to be ordered into a 
set of nodes and edges in a deterministic way. This is easy to do when all of 
the nodes have unique names, but very difficult to do when some of the nodes 
are not labeled.
</p>

<p>In time, there may be more than one normalization algorithm that will need
to be identified. For identification purposes, this algorithm is named 
<abbr title="Universal Graph Normalization Algorithm 2011">UGNA2011</abbr>.
</p>

<div id="normalization-algorithm-terms" class="section">
<h4><span class="secno">6.11.1 </span>Normalization Algorithm Terms</h4>
 <dl>
   <dt><dfn title="label" id="dfn-label">label</dfn></dt>
   <dd>
     The subject IRI associated with a graph node. The subject IRI is expressed
     using a key-value pair in a <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a> where the key is
     <code>@subject</code> and the value is a string that is an IRI or 
     a <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a> containing the key <code>@iri</code> and
     a value that is a string that is an IRI.
   </dd>
   <dt><dfn title="list_of_expanded_nodes" id="dfn-list_of_expanded_nodes">list of expanded nodes</dfn></dt>
   <dd>
     A list of all nodes in the <a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input">JSON-LD input</a> graph containing no
     embedded objects and having all keys and values expanded according to the
     steps in the <a href="#expansion-algorithm">Expansion Algorithm</a>.
   </dd>
   <dt><dfn title="alpha" id="dfn-alpha">alpha</dfn> and <dfn title="beta" id="dfn-beta">beta</dfn> values</dt>
   <dd>
     The words <a class="tref internalDFN" title="alpha" href="#dfn-alpha">alpha</a> and <a class="tref internalDFN" title="beta" href="#dfn-beta">beta</a> refer to the first and
     second nodes or values being examined in an algorithm. The names are
     merely used to refer to each input value to a comparison algorithm.
   </dd>
   <dt><dfn title="renaming_counter" id="dfn-renaming_counter">renaming counter</dfn></dt>
   <dd>
     A counter that is used during the 
     <a href="#node-relabeling-algorithm">Node Relabeling Algorithm</a>. The
     counter typically starts at one (1) and counts up for every node that is
     relabeled. There will be two such renaming counters in an implementation
     of the normalization algorithm. The first is the
     <a class="tref internalDFN" title="labeling_counter" href="#dfn-labeling_counter">labeling counter</a> and the second is the
     <a class="tref" title="deterministic_labeling_counter">deterministic labeling counter</a>.
   </dd>
   <dt><dfn title="serialization_label" id="dfn-serialization_label">serialization label</dfn></dt>
   <dd>
     An identifier that is created to aid in the normalization process in the
     <a href="#deep-comparison-algorithm">Deep Comparison Algorithm</a>. The
     value typically takes the form of <code>s<NUMBER></code> or 
     <code>c<NUMBER></code>.
   </dd>
</dl>
</div>

<div id="normalization-state" class="section">
<h4><span class="secno">6.11.2 </span>Normalization State</h4>

<p>When performing the steps required by the normalization algorithm, 
it is helpful to track the many pieces of information in a
data structure called the <dfn title="normalization_state" id="dfn-normalization_state">normalization state</dfn>. Many of these
pieces simply provide indexes into the graph. The information
contained in the <a class="tref internalDFN" title="normalization_state" href="#dfn-normalization_state">normalization state</a> is described below.</p>

<dl>
   <dt><dfn title="node_state" id="dfn-node_state">node state</dfn></dt>
   <dd>
     Each node in the graph will be assigned a <a class="tref internalDFN" title="node_state" href="#dfn-node_state">node state</a>. This
     state contains the information necessary to deterministically
     <a class="tref internalDFN" title="label" href="#dfn-label">label</a> all nodes in the graph. A <a class="tref internalDFN" title="node_state" href="#dfn-node_state">node state</a>
     includes:
     <dl>
        <dt><dfn title="node_reference" id="dfn-node_reference">node reference</dfn></dt>
        <dd>
          A <a class="tref internalDFN" title="node_reference" href="#dfn-node_reference">node reference</a> is a reference to a node in the graph.
          For a given <a class="tref internalDFN" title="node_state" href="#dfn-node_state">node state</a>, its <a class="tref internalDFN" title="node_reference" href="#dfn-node_reference">node reference</a>
          refers to the node that the state is for. When a
          <a class="tref internalDFN" title="node_state" href="#dfn-node_state">node state</a> is created, its <a class="tref internalDFN" title="node_reference" href="#dfn-node_reference">node reference</a>
          should be to the node it is created for.
        </dd>
        <dt><dfn title="outgoing_list" id="dfn-outgoing_list">outgoing list</dfn></dt>
        <dd>
          Lists the <a class="tref internalDFN" title="label" href="#dfn-label">label</a>s for all nodes that are properties of
          the <a class="tref internalDFN" title="node_reference" href="#dfn-node_reference">node reference</a>. This list should be initialized
          by iterating over every object associated with a property in the
          <a class="tref internalDFN" title="node_reference" href="#dfn-node_reference">node reference</a> adding its label if it is another node.
        </dd>
        <dt><dfn title="incoming_list" id="dfn-incoming_list">incoming list</dfn></dt>
        <dd>
          Lists the <a class="tref internalDFN" title="label" href="#dfn-label">label</a>s for all nodes in the graph for which
          the <a class="tref internalDFN" title="node_reference" href="#dfn-node_reference">node reference</a> is a property. This list is 
          initialized to an empty list.
        </dd>
        <dt><dfn title="outgoing_serialization_map" id="dfn-outgoing_serialization_map">outgoing serialization map</dfn></dt>
        <dd>
          Maps node <a class="tref internalDFN" title="label" href="#dfn-label">label</a>s to <a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1">serialization label</a>s.
          This map is initialized to an empty map. When this map is populated,
          it will be filled with keys that are the <a class="tref internalDFN" title="label" href="#dfn-label">label</a>s of every node in the
          graph with a label that begins with <code>_:</code> and that has a
          path, via properties, that starts with the
          <a class="tref internalDFN" title="node_reference" href="#dfn-node_reference">node reference</a>.
        </dd>
        <dt><dfn title="outgoing_serialization" id="dfn-outgoing_serialization">outgoing serialization</dfn></dt>
        <dd>
          A string that can be lexicographically compared to the
          <a class="tref internalDFN" title="outgoing_serialization" href="#dfn-outgoing_serialization">outgoing serialization</a>s of other
          <a class="tref internalDFN" title="node_state" href="#dfn-node_state">node state</a>s. It is a representation of the
          <a class="tref internalDFN" title="outgoing_serialization_map" href="#dfn-outgoing_serialization_map">outgoing serialization map</a> and other related
          information. This string is initialized to an empty string.
        </dd>
        <dt><dfn title="incoming_serialization_map" id="dfn-incoming_serialization_map">incoming serialization map</dfn></dt>
        <dd>
          Maps node <a class="tref internalDFN" title="label" href="#dfn-label">label</a>s to <a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1">serialization label</a>s.
          This map is initialized to an empty map. When this map is populated,
          it will be filled with keys that are the <a class="tref internalDFN" title="label" href="#dfn-label">label</a>s of every
          node in the graph with a <a class="tref internalDFN" title="label" href="#dfn-label">label</a> that begins with
          <code>_:</code> and that has a path, via properties, that ends with
          the <a class="tref internalDFN" title="node_reference" href="#dfn-node_reference">node reference</a>.
        </dd>
        <dt><dfn title="incoming_serialization" id="dfn-incoming_serialization">incoming serialization</dfn></dt>
        <dd>
          A string that can be lexicographically compared to the
          <a class="tref internalDFN" title="outgoing_serialization" href="#dfn-outgoing_serialization">outgoing serialization</a>s of other
          <a class="tref internalDFN" title="node_state" href="#dfn-node_state">node state</a>s. It is a representation of the
          <a class="tref internalDFN" title="incoming_serialization_map" href="#dfn-incoming_serialization_map">incoming serialization map</a> and other related
          information. This string is initialized to an empty string.
        </dd>
     </dl>
   </dd>
   <dt><dfn title="node_state_map" id="dfn-node_state_map">node state map</dfn></dt>
   <dd>
     A mapping from a node's <a class="tref internalDFN" title="label" href="#dfn-label">label</a> to a <a class="tref internalDFN" title="node_state" href="#dfn-node_state">node state</a>.
     It is initialized to an empty map.
   </dd>
   <dt><dfn title="labeling_prefix" id="dfn-labeling_prefix">labeling prefix</dfn></dt>
   <dd>
     The labeling prefix is a string that is used as the beginning of a node
     <a class="tref internalDFN" title="label" href="#dfn-label">label</a>. It should be initialized to a random base string that
     starts with the characters <code>_:</code>, is not used by any other
     node's <a class="tref internalDFN" title="label" href="#dfn-label">label</a> in the <a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input">JSON-LD input</a>, and does not
     start with the characters <code>_:c14n</code>. The prefix has two uses.
     First it is used to temporarily name nodes during the normalization
     algorithm in a way that doesn't collide with the names that already
     exist as well as the names that will be generated by the normalization
     algorithm. Second, it will eventually be set to <code>_:c14n</code> to
     generate the final, deterministic labels for nodes in the graph. This
     prefix will be concatenated with the <a class="tref internalDFN" title="labeling_counter" href="#dfn-labeling_counter">labeling counter</a> to
     produce a node <a class="tref internalDFN" title="label" href="#dfn-label">label</a>. For example, <code>_:j8r3k</code> is
     a proper initial value for the <a class="tref internalDFN" title="labeling_prefix" href="#dfn-labeling_prefix">labeling prefix</a>.
   </dd>
   <dt><dfn title="labeling_counter" id="dfn-labeling_counter">labeling counter</dfn></dt>
   <dd>
     A counter that is used to label nodes. It is appended to the
     <a class="tref internalDFN" title="labeling_prefix" href="#dfn-labeling_prefix">labeling prefix</a> to create a node <a class="tref internalDFN" title="label" href="#dfn-label">label</a>. It is
     initialized to <code>1</code>.
   </dd>
   <dt><dfn title="map_of_flattened_nodes" id="dfn-map_of_flattened_nodes">map of flattened nodes</dfn></dt>
   <dd>
     A map containing a representation of all nodes in the graph where the
     key is a node <a class="tref internalDFN" title="label" href="#dfn-label">label</a> and the value is a single
     <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a> that has no nested sub-objects 
     and has had all properties for the same node merged into a single
     <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a>.
   </dd>
</dl>

</div>

<div id="normalization-algorithm" class="section">
<h4><span class="secno">6.11.3 </span>Normalization Algorithm</h4>

<p>The normalization algorithm expands the <a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input">JSON-LD input</a>,
flattens the data structure, and creates an initial set of names for all
nodes in the graph. The flattened data structure is then processed by a
node labeling algorithm in order to get a fully expanded and named list of
nodes which is then sorted. The result is a deterministically named and
ordered list of graph nodes.
</p>

<ol class="algorithm">
<li>Expand the <a class="tref internalDFN" title="JSON-LD_input" href="#dfn-json-ld_input">JSON-LD input</a> according to the steps in
the <a href="#expansion-algorithm">Expansion Algorithm</a> and store the
result as the <strong>expanded input</strong>.</li>
<li>Create a <a class="tref internalDFN" title="normalization_state" href="#dfn-normalization_state">normalization state</a>.</li>
<li>Initialize the <a class="tref internalDFN" title="map_of_flattened_nodes" href="#dfn-map_of_flattened_nodes">map of flattened nodes</a> by recursively 
processing every <dfn title="expanded_node" id="dfn-expanded_node">expanded node</dfn> in the 
<strong>expanded input</strong> in depth-first order:
  <ol class="algorithm">
    <li>If the <a class="tref internalDFN" title="expanded_node" href="#dfn-expanded_node">expanded node</a> is an unlabeled node, add a 
      new key-value pair to the <a class="tref internalDFN" title="expanded_node" href="#dfn-expanded_node">expanded node</a>
      where the key is <code>@subject</code> and the value is the 
      concatenation of the <a class="tref internalDFN" title="labeling_prefix" href="#dfn-labeling_prefix">labeling prefix</a> 
      and the string value of the <a class="tref internalDFN" title="labeling_counter" href="#dfn-labeling_counter">labeling counter</a>.
      Increment the <a class="tref internalDFN" title="labeling_counter" href="#dfn-labeling_counter">labeling counter</a>.</li>
    <li>Add the <a class="tref internalDFN" title="expanded_node" href="#dfn-expanded_node">expanded node</a> to the 
      <a class="tref internalDFN" title="map_of_flattened_nodes" href="#dfn-map_of_flattened_nodes">map of flattened nodes</a>:
      <ol class="algorithm">
        <li>If the <a class="tref internalDFN" title="expanded_node" href="#dfn-expanded_node">expanded node</a>'s <a class="tref internalDFN" title="label" href="#dfn-label">label</a> is already 
          in the 
          <a class="tref internalDFN" title="map_of_flattened_nodes" href="#dfn-map_of_flattened_nodes">map of flattened nodes</a> merge all properties from the 
          entry in the <a class="tref internalDFN" title="map_of_flattened_nodes" href="#dfn-map_of_flattened_nodes">map of flattened nodes</a> into the 
          <a class="tref internalDFN" title="expanded_node" href="#dfn-expanded_node">expanded node</a>.</li>
        <li>Go through every property associated with an array in the 
          <a class="tref internalDFN" title="expanded_node" href="#dfn-expanded_node">expanded node</a> and remove any duplicate IRI entries from
          the array. If the resulting array only has one IRI entry, change it 
          from an array to an object.</li>
        <li>Set the entry for the <a class="tref internalDFN" title="expanded_node" href="#dfn-expanded_node">expanded node</a>'s <a class="tref internalDFN" title="label" href="#dfn-label">label</a>
          in the <a class="tref internalDFN" title="map_of_flattened_nodes" href="#dfn-map_of_flattened_nodes">map of flattened nodes</a> to the
          <a class="tref internalDFN" title="expanded_node" href="#dfn-expanded_node">expanded node</a>.
        </li></ol></li>
    <li>After exiting the recursive step, replace the reference to the
      <a class="tref internalDFN" title="expanded_node" href="#dfn-expanded_node">expanded node</a> with an object containing a single
       key-value pair where the key is <code>@iri</code> and the value is
       the value of the <code>@subject</code> key in the node.</li>
  </ol></li>
<li>For every entry in the <a class="tref internalDFN" title="map_of_flattened_nodes" href="#dfn-map_of_flattened_nodes">map of flattened nodes</a>, insert a
  key-value pair into the <a class="tref internalDFN" title="node_state_map" href="#dfn-node_state_map">node state map</a> where the key is the
  key from the <a class="tref internalDFN" title="map_of_flattened_nodes" href="#dfn-map_of_flattened_nodes">map of flattened nodes</a> and the value is a
  <a class="tref internalDFN" title="node_state" href="#dfn-node_state">node state</a> where its <a class="tref internalDFN" title="node_reference" href="#dfn-node_reference">node reference</a> refers to
  the value from the <a class="tref internalDFN" title="map_of_flattened_nodes" href="#dfn-map_of_flattened_nodes">map of flattened nodes</a>.
</li><li>Populate the <a class="tref internalDFN" title="incoming_list" href="#dfn-incoming_list">incoming list</a> for each <a class="tref internalDFN" title="node_state" href="#dfn-node_state">node state</a>
  by iterating over every node in the graph and adding its <a class="tref internalDFN" title="label" href="#dfn-label">label</a>
  to the <a class="tref internalDFN" title="incoming_list" href="#dfn-incoming_list">incoming list</a> associated with each node found in its
  properties.</li>
<li>For every entry in the <a class="tref internalDFN" title="node_state_map" href="#dfn-node_state_map">node state map</a> that has a 
<a class="tref internalDFN" title="label" href="#dfn-label">label</a> that begins with <code>_:c14n</code>, relabel the node
using the <a href="#node-relabeling-algorithm">Node Relabeling Algorithm</a>.
</li><li>Label all of the nodes that contain a <code>@subject</code> key associated
with a value starting with <code>_:</code> according to the steps in the 
<a href="#deterministic-labeling-algorithm">Deterministic Labeling Algorithm</a>.
</li>
</ol>
</div>

<div id="node-relabeling-algorithm" class="section">
<h4><span class="secno">6.11.4 </span>Node Relabeling Algorithm</h4>

<p>This algorithm renames a node by generating a unique 
<dfn title="new_label" id="dfn-new_label">new label</dfn> and updating all references to that <a class="tref internalDFN" title="label" href="#dfn-label">label</a>
in the <a class="tref internalDFN" title="node_state_map" href="#dfn-node_state_map">node state map</a>. The <dfn title="old_label" id="dfn-old_label">old label</dfn> and the
<a class="tref internalDFN" title="normalization_state" href="#dfn-normalization_state">normalization state</a> must be given as an input to the
algorithm. The <a class="tref internalDFN" title="old_label" href="#dfn-old_label">old label</a> is the current <a class="tref internalDFN" title="label" href="#dfn-label">label</a> of
the node that is to be relabeled.

</p><p>The node relabeling algorithm is as follows:</p>

<ol class="algorithm">
  <li>If the <a class="tref internalDFN" title="labeling_prefix" href="#dfn-labeling_prefix">labeling prefix</a> is <code>_:c14n</code> and the
    <a class="tref internalDFN" title="old_label" href="#dfn-old_label">old label</a> begins with <code>_:c14n</code> then return as
    the node has already been renamed.
  </li>
  <li>Generate the <dfn title="new_label" id="dfn-new_label-1">new label</dfn> by concatenating the
    <a class="tref internalDFN" title="labeling_prefix" href="#dfn-labeling_prefix">labeling prefix</a> with the string value of the 
    <a class="tref internalDFN" title="labeling_counter" href="#dfn-labeling_counter">labeling counter</a>. Increment the <a class="tref internalDFN" title="labeling_counter" href="#dfn-labeling_counter">labeling counter</a>.
  </li>
  <li>For the <a class="tref internalDFN" title="node_state" href="#dfn-node_state">node state</a> associated with the
  <a class="tref internalDFN" title="old_label" href="#dfn-old_label">old label</a>, update every node in the <a class="tref internalDFN" title="incoming_list" href="#dfn-incoming_list">incoming list</a>
  by changing all the properties that reference the <a class="tref internalDFN" title="old_label" href="#dfn-old_label">old label</a> to
  the <a class="tref internalDFN" title="new_label" href="#dfn-new_label-1">new label</a>.
  </li>
  <li>Change the <a class="tref internalDFN" title="old_label" href="#dfn-old_label">old label</a> key in the <a class="tref internalDFN" title="node_state_map" href="#dfn-node_state_map">node state map</a> 
    to the <a class="tref internalDFN" title="new_label" href="#dfn-new_label-1">new label</a> and set the associated
    <a class="tref internalDFN" title="node_reference" href="#dfn-node_reference">node reference</a>'s <a class="tref internalDFN" title="label" href="#dfn-label">label</a> to the
    <a class="tref internalDFN" title="new_label" href="#dfn-new_label-1">new label</a>.
  </li>
</ol>
</div>

<div id="deterministic-labeling-algorithm" class="section">
<h4><span class="secno">6.11.5 </span>Deterministic Labeling Algorithm</h4>

<p>The deterministic labeling algorithm takes the 
<a class="tref internalDFN" title="normalization_state" href="#dfn-normalization_state">normalization state</a>
and produces a <dfn title="list_of_finished_nodes" id="dfn-list_of_finished_nodes">list of finished nodes</dfn> that is sorted and
contains deterministically named and expanded nodes from the graph.

</p><ol class="algorithm">
  <li>Set the <a class="tref internalDFN" title="labeling_prefix" href="#dfn-labeling_prefix">labeling prefix</a> to <code>_:c14n</code>, the
    <a class="tref internalDFN" title="labeling_counter" href="#dfn-labeling_counter">labeling counter</a> to <code>1</code>,
    the <dfn title="list_of_finished_nodes" id="dfn-list_of_finished_nodes-1">list of finished nodes</dfn> to an empty array, and create
    an empty array, the <dfn title="list_of_unfinished_nodes" id="dfn-list_of_unfinished_nodes">list of unfinished nodes</dfn>.</li>
  <li>For each <a class="tref internalDFN" title="node_reference" href="#dfn-node_reference">node reference</a> in the <a class="tref internalDFN" title="node_state_map" href="#dfn-node_state_map">node state map</a>:
    <ol class="algorithm">
      <li>If the node's <a class="tref internalDFN" title="label" href="#dfn-label">label</a> does not start with <code>_:</code>
        then put the <a class="tref internalDFN" title="node_reference" href="#dfn-node_reference">node reference</a> in the
        <a class="tref internalDFN" title="list_of_finished_nodes" href="#dfn-list_of_finished_nodes-1">list of finished nodes</a>.
      </li>
      <li>If the node's <a class="tref internalDFN" title="label" href="#dfn-label">label</a> does start with <code>_:</code>
        then put the <a class="tref internalDFN" title="node_reference" href="#dfn-node_reference">node reference</a> in the
        <a class="tref internalDFN" title="list_of_unfinished_nodes" href="#dfn-list_of_unfinished_nodes">list of unfinished nodes</a>.
      </li>
    </ol>
  </li>
  <li>Append to the <a class="tref internalDFN" title="list_of_finished_nodes" href="#dfn-list_of_finished_nodes-1">list of finished nodes</a> by processing
    the remainder of the <a class="tref internalDFN" title="list_of_unfinished_nodes" href="#dfn-list_of_unfinished_nodes">list of unfinished nodes</a> until it is
    empty:
    <ol class="algorithm">
      <li>Sort the <a class="tref internalDFN" title="list_of_unfinished_nodes" href="#dfn-list_of_unfinished_nodes">list of unfinished nodes</a> in descending order 
        according to the 
        <a href="#deep-comparison-algorithm">Deep Comparison Algorithm</a> to
        determine the sort order.</li>
      <li>Create a <dfn title="list_of_labels" id="dfn-list_of_labels">list of labels</dfn> and initialize it to an
        empty array.</li>
      <li>For the first node from the <a class="tref internalDFN" title="list_of_unfinished_nodes" href="#dfn-list_of_unfinished_nodes">list of unfinished nodes</a>:
        <ol class="algorithm">
          <li>Add its <a class="tref internalDFN" title="label" href="#dfn-label">label</a> to the <a class="tref internalDFN" title="list_of_labels" href="#dfn-list_of_labels">list of labels</a>.
          </li>
          <li>For each key-value pair from its associated
            <a class="tref internalDFN" title="outgoing_serialization_map" href="#dfn-outgoing_serialization_map">outgoing serialization map</a>, add the key to a list and
            then sort the list according to the lexicographical order of the
            keys' associated values. Append the list to the
            <a class="tref" title="list_of_nodes_to_label">list of nodes to label</a>.
          </li>
          <li>For each key-value pair from its associated
            <a class="tref internalDFN" title="incoming_serialization_map" href="#dfn-incoming_serialization_map">incoming serialization map</a>, add the key to a list and
            then sort the list according to the lexicographical order of the
            keys' associated values. Append the list to the
            <a class="tref" title="list_of_nodes_to_label">list of nodes to label</a>.
          </li></ol></li>
      <li>For each <a class="tref internalDFN" title="label" href="#dfn-label">label</a> in the <a class="tref internalDFN" title="list_of_labels" href="#dfn-list_of_labels">list of labels</a>,
        relabel the associated node according to the 
        <a href="#node-relabeling-algorithm">Node Relabeling Algorithm</a>. If
        any <a class="tref internalDFN" title="outgoing_serialization_map" href="#dfn-outgoing_serialization_map">outgoing serialization map</a> contains a key that
        matches the <a class="tref internalDFN" title="label" href="#dfn-label">label</a>, clear the map and set the associated
        <a class="tref internalDFN" title="outgoing_serialization" href="#dfn-outgoing_serialization">outgoing serialization</a> to an empty string. If any
        <a class="tref internalDFN" title="incoming_serialization_map" href="#dfn-incoming_serialization_map">incoming serialization map</a> contains a key that
        matches the <a class="tref internalDFN" title="label" href="#dfn-label">label</a>, clear the map and set the associated
        <a class="tref internalDFN" title="incoming_serialization" href="#dfn-incoming_serialization">incoming serialization</a> to an empty string.
      </li>
      <li>
        Remove each node with a <a class="tref internalDFN" title="label" href="#dfn-label">label</a> that starts with
        <code>_:c14n</code> from the <a class="tref internalDFN" title="list_of_unfinished_nodes" href="#dfn-list_of_unfinished_nodes">list of unfinished nodes</a> and
        add it to the <a class="tref internalDFN" title="list_of_finished_nodes" href="#dfn-list_of_finished_nodes-1">list of finished nodes</a>.
      </li>
    </ol>
  </li>
  <li>Sort the <a class="tref internalDFN" title="list_of_finished_nodes" href="#dfn-list_of_finished_nodes-1">list of finished nodes</a> in descending order 
    according to the 
    <a href="#deep-comparison-algorithm">Deep Comparison Algorithm</a> to
    determine the sort order.</li>
</ol>
</div>

<div id="shallow-comparison-algorithm" class="section">
<h4><span class="secno">6.11.6 </span>Shallow Comparison Algorithm</h4>

<p>
The shallow comparison algorithm takes two unlabeled nodes,
<a class="tref internalDFN" title="alpha" href="#dfn-alpha">alpha</a> and <a class="tref internalDFN" title="beta" href="#dfn-beta">beta</a>, as input and
determines which one should come first in a sorted list. The following
algorithm determines the steps that are executed in order to determine the
node that should come first in a list:
</p>

<ol class="algorithm">
  <li>Compare the total number of node properties. The node with fewer 
    properties is first.</li>
  <li>Lexicographically sort the property IRIs for each node and compare
    the sorted lists. If an IRI is found to be lexicographically smaller, the
    node containing that IRI is first.</li>
  <li>Compare the property values against one another:
    <ol class="algorithm">
      <li>Create an <dfn title="alpha_list" id="dfn-alpha_list">alpha list</dfn> by adding all values associated 
        with the <a class="tref internalDFN" title="alpha" href="#dfn-alpha">alpha</a> property that is not an unlabeled node.
        Track the number of unlabeled nodes not added to the list using an
        <dfn title="alpha_unlabeled_counter" id="dfn-alpha_unlabeled_counter">alpha unlabeled counter</dfn>.</li>
      <li>Create a <dfn title="beta_list" id="dfn-beta_list">beta list</dfn> by adding all values associated 
        with the <a class="tref internalDFN" title="beta" href="#dfn-beta">beta</a> property that is not an unlabeled node. 
        Track the number of unlabeled nodes not added to the list using an
        <dfn title="beta_unlabeled_counter" id="dfn-beta_unlabeled_counter">beta unlabeled counter</dfn>.
      </li><li>Compare the length of <a class="tref internalDFN" title="alpha_list" href="#dfn-alpha_list">alpha list</a> and 
        <a class="tref internalDFN" title="beta_list" href="#dfn-beta_list">beta list</a>. The node associated with the list containing the
        lesser number of items is first.</li>
      <li>Compare the <a class="tref internalDFN" title="alpha_unlabeled_counter" href="#dfn-alpha_unlabeled_counter">alpha unlabeled counter</a> to the 
        <a class="tref internalDFN" title="beta_unlabeled_counter" href="#dfn-beta_unlabeled_counter">beta unlabeled counter</a>, the node associated with the lesser
        value is first.</li>
      <li>Sort <a class="tref internalDFN" title="alpha_list" href="#dfn-alpha_list">alpha list</a> and <a class="tref internalDFN" title="beta_list" href="#dfn-beta_list">beta list</a> according to
        the
        <a href="#object-comparison-algorithm">Object Comparison Algorithm</a>
        as the sorting comparator.
        For each offset into the <a class="tref internalDFN" title="alpha_list" href="#dfn-alpha_list">alpha list</a>, compare the item
        at the offset against the item at the same offset in the 
        <a class="tref internalDFN" title="beta_list" href="#dfn-beta_list">beta list</a> according to the
        <a href="#object-comparison-algorithm">Object Comparison Algorithm</a>.
        The node associated with the lesser item is first.
    </li></ol></li>
  <li>Process the <a class="tref internalDFN" title="incoming_list" href="#dfn-incoming_list">incoming list</a>s associated with each node to
    determine order:
    <ol class="algorithm">
      <li>The node with the shortest <a class="tref internalDFN" title="incoming_list" href="#dfn-incoming_list">incoming list</a> is first.</li>
      <li>Sort the <a class="tref internalDFN" title="incoming_list" href="#dfn-incoming_list">incoming list</a>s according to incoming property
         and then incoming <a class="tref internalDFN" title="label" href="#dfn-label">label</a>.
      </li><li>The node associated with the least number of incoming unlabeled
         nodes is first.</li>
      <li>For each offset into the <a class="tref internalDFN" title="incoming_list" href="#dfn-incoming_list">incoming list</a>s, 
        compare the associated properties and <a class="tref internalDFN" title="label" href="#dfn-label">label</a>s.
        The node associated with the lexicographically lesser associated
        property is first. The node associated with the lexicographically
        lesser <a class="tref internalDFN" title="label" href="#dfn-label">label</a> is first.</li>
    </ol></li>
  <li>Otherwise, the nodes are equivalent.</li>
</ol></div>

<div id="object-comparison-algorithm" class="section">
<h4><span class="secno">6.11.7 </span>Object Comparison Algorithm</h4>

<p>
The object comparison algorithm is designed to compare two graph node 
property values, <a class="tref internalDFN" title="alpha" href="#dfn-alpha">alpha</a> and <a class="tref internalDFN" title="beta" href="#dfn-beta">beta</a>, against the other.
The algorithm is useful when sorting two lists of graph node properties.
</p>

<ol class="algorithm">
  <li>If one of the values is a <a class="tref internalDFN" title="string" href="#dfn-string">string</a> and the other is not, the value that is
    a string is first.</li>
  <li>If both values are <a class="tref internalDFN" title="string" href="#dfn-string">string</a>s, the lexicographically lesser string is
    first.</li>
  <li>If one of the values is a literal and the other is not, the value that is
    a literal is first.</li>
  <li>If both values are literals
    <ol class="algorithm">
      <li>The lexicographically lesser string associated with 
        <code>@literal</code> is first.</li>
      <li>The lexicographically lesser string associated with 
        <code>@datatype</code> is first.</li>
      <li>The lexicographically lesser string associated with 
        <code>@language</code> is first.</li>
    </ol></li>
  <li>If both values are expanded IRIs, the 
    lexicographically lesser string associated with <code>@iri</code> 
    is first.</li>
  <li>Otherwise, the two values are equivalent.</li>
</ol>

</div>

<div id="deep-comparison-algorithm" class="section">
<h4><span class="secno">6.11.8 </span>Deep Comparison Algorithm</h4>

<p>
The deep comparison algorithm is used to compare the difference between two
nodes, <a class="tref internalDFN" title="alpha" href="#dfn-alpha">alpha</a> and <a class="tref internalDFN" title="beta" href="#dfn-beta">beta</a>. 
A deep comparison takes the incoming and outgoing node edges in
a graph into account if the number of properties and value of those properties 
are identical. The algorithm is helpful when sorting a list of nodes and will
return whichever node should be placed first in a list if the two nodes are
not truly equivalent.
</p>

<p>When performing the steps required by the deep comparison algorithm, it
is helpful to track state information about mappings. The information
contained in a <a class="tref internalDFN" title="mapping_state" href="#dfn-mapping_state">mapping state</a> is described below.</p>

<dl class="algorithm">
   <dt><dfn title="mapping_state" id="dfn-mapping_state">mapping state</dfn></dt>
   <dd>
     <dl>
        <dt><dfn title="mapping_counter" id="dfn-mapping_counter">mapping counter</dfn></dt>
        <dd>
          Keeps track of the number of nodes that have been mapped to
          <a class="tref" title="serialization_labels">serialization labels</a>. It is initialized to
          <code>1</code>.
        </dd>
        <dt><dfn title="processed_labels_map" id="dfn-processed_labels_map">processed labels map</dfn></dt>
        <dd>
          Keeps track of the <a class="tref internalDFN" title="label" href="#dfn-label">label</a>s of nodes that have already
          been assigned <a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1">serialization label</a>s. It is initialized
          to an empty map.
        </dd>
        <dt><dfn title="serialized_labels_map" id="dfn-serialized_labels_map">serialized labels map</dfn></dt>
        <dd>
          Maps a node <a class="tref internalDFN" title="label" href="#dfn-label">label</a> to its associated
          <a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1">serialization label</a>. It is initialized to an empty map.
        </dd>
        <dt><dfn title="adjacent_info_map" id="dfn-adjacent_info_map">adjacent info map</dfn></dt>
        <dd>
          Maps a <a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1">serialization label</a> to the node
          <a class="tref internalDFN" title="label" href="#dfn-label">label</a> associated with it, the list of sorted
          <a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1">serialization label</a>s for adjacent nodes, and the map of
          adjacent node <a class="tref" title="serialiation_label">serialiation label</a>s to their associated
          node <a class="tref internalDFN" title="label" href="#dfn-label">label</a>s. It is initialized to an empty map.
        </dd>
        <dt><dfn title="key_stack" id="dfn-key_stack">key stack</dfn></dt>
        <dd>
          A stack where each element contains an array of adjacent
          <a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1">serialization label</a>s and an index into that array. It
          is initialized to a stack containing a single element where its
          array contains a single string element <code>s1</code> and its
          index is set to <code>0</code>.
        </dd>
        <dt><dfn title="serialized_keys" id="dfn-serialized_keys">serialized keys</dfn></dt>
        <dd>
          Keeps track of which <a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1">serialization label</a>s have already
          been written at least once to the <a class="tref internalDFN" title="serialization_string" href="#dfn-serialization_string">serialization string</a>.
          It is initialized to an empty map.
        </dd>
        <dt><dfn title="serialization_string" id="dfn-serialization_string">serialization string</dfn></dt>
        <dd>
          A string that is incrementally updated as a serialization is built.
          It is initialized to an empty string.
        </dd>
     </dl>
   </dd>
</dl>

<p>The deep comparison algorithm is as follows:</p>
   
<ol class="algorithm">
  <li>Perform a comparison between <a class="tref internalDFN" title="alpha" href="#dfn-alpha">alpha</a> and <a class="tref internalDFN" title="beta" href="#dfn-beta">beta</a>
    according to the 
    <a href="#shallow-comparison-algorithm">Shallow Comparison Algorithm</a>.
    If the result does not show that the two nodes are equivalent, return 
    the result.
    </li>
  <li>Compare incoming and outgoing edges for each node, updating their
    associated <a class="tref internalDFN" title="node_state" href="#dfn-node_state">node state</a> as each node is processed:
    <ol class="algorithm">
      <li>If the <a class="tref internalDFN" title="outgoing_serialization_map" href="#dfn-outgoing_serialization_map">outgoing serialization map</a> for <a class="tref internalDFN" title="alpha" href="#dfn-alpha">alpha</a>
        is empty, generate the serialization according to the 
        <a href="#node-serialization-algorithm">Node Serialization Algorithm</a>.
        Provide <a class="tref internalDFN" title="alpha" href="#dfn-alpha">alpha</a>'s <a class="tref internalDFN" title="node_state" href="#dfn-node_state">node state</a>, a new
        <a class="tref internalDFN" title="mapping_state" href="#dfn-mapping_state">mapping state</a>,
        <code>outgoing direction</code> to the algorithm as inputs.       
      </li><li>If the <a class="tref internalDFN" title="outgoing_serialization_map" href="#dfn-outgoing_serialization_map">outgoing serialization map</a> for <a class="tref internalDFN" title="beta" href="#dfn-beta">beta</a>
        is empty, generate the serialization according to the 
        <a href="#node-serialization-algorithm">Node Serialization Algorithm</a>.
        Provide <a class="tref internalDFN" title="beta" href="#dfn-beta">beta</a>'s <a class="tref internalDFN" title="node_state" href="#dfn-node_state">node state</a>, a new
        <a class="tref internalDFN" title="mapping_state" href="#dfn-mapping_state">mapping state</a>, and
        <code>outgoing direction</code> to the algorithm as inputs.
      </li><li>If <a class="tref internalDFN" title="alpha" href="#dfn-alpha">alpha</a>'s <a class="tref internalDFN" title="outgoing_serialization" href="#dfn-outgoing_serialization">outgoing serialization</a> is
        lexicographically less than <a class="tref internalDFN" title="beta" href="#dfn-beta">beta</a>'s, then 
        <a class="tref internalDFN" title="alpha" href="#dfn-alpha">alpha</a> is first. If it is greater, then <a class="tref internalDFN" title="beta" href="#dfn-beta">beta</a>
        is first.</li>
      <li>If the <a class="tref internalDFN" title="incoming_serialization_map" href="#dfn-incoming_serialization_map">incoming serialization map</a> for <a class="tref internalDFN" title="alpha" href="#dfn-alpha">alpha</a>
        is empty, generate the serialization according to the 
        <a href="#node-serialization-algorithm">Node Serialization Algorithm</a>.
        Provide <a class="tref internalDFN" title="alpha" href="#dfn-alpha">alpha</a>'s <a class="tref internalDFN" title="node_state" href="#dfn-node_state">node state</a>, a new
        <a class="tref internalDFN" title="mapping_state" href="#dfn-mapping_state">mapping state</a> with its <a class="tref internalDFN" title="serialized_labels_map" href="#dfn-serialized_labels_map">serialized labels map</a>
        set to a copy of <a class="tref internalDFN" title="alpha" href="#dfn-alpha">alpha</a>'s
        <a class="tref internalDFN" title="outgoing_serialization_map" href="#dfn-outgoing_serialization_map">outgoing serialization map</a>, and
        <code>incoming direction</code> to the algorithm as inputs.
      </li><li>If the <a class="tref internalDFN" title="incoming_serialization_map" href="#dfn-incoming_serialization_map">incoming serialization map</a> for <a class="tref internalDFN" title="beta" href="#dfn-beta">beta</a>
        is empty, generate the serialization according to the 
        <a href="#node-serialization-algorithm">Node Serialization Algorithm</a>.
        Provide <a class="tref internalDFN" title="beta" href="#dfn-beta">beta</a>'s <a class="tref internalDFN" title="node_state" href="#dfn-node_state">node state</a>, a new
        <a class="tref internalDFN" title="mapping_state" href="#dfn-mapping_state">mapping state</a> with its <a class="tref internalDFN" title="serialized_labels_map" href="#dfn-serialized_labels_map">serialized labels map</a>
        set to a copy of <a class="tref internalDFN" title="beta" href="#dfn-beta">beta</a>'s
        <a class="tref internalDFN" title="outgoing_serialization_map" href="#dfn-outgoing_serialization_map">outgoing serialization map</a>, and
        <code>incoming direction</code> to the algorithm as inputs.
      </li><li>If <a class="tref internalDFN" title="alpha" href="#dfn-alpha">alpha</a>'s <a class="tref internalDFN" title="incoming_serialization" href="#dfn-incoming_serialization">incoming serialization</a> is
        lexicographically less than <a class="tref internalDFN" title="beta" href="#dfn-beta">beta</a>'s, then 
        <a class="tref internalDFN" title="alpha" href="#dfn-alpha">alpha</a> is first. If it is greater, then <a class="tref internalDFN" title="beta" href="#dfn-beta">beta</a>
        is first.</li>
    </ol></li>
</ol>
</div>

<div id="node-serialization-algorithm" class="section">
<h4><span class="secno">6.11.9 </span>Node Serialization Algorithm</h4>

<p>
The node serialization algorithm takes a <a class="tref internalDFN" title="node_state" href="#dfn-node_state">node state</a>, a
<a class="tref internalDFN" title="mapping_state" href="#dfn-mapping_state">mapping state</a>, and a <dfn title="direction" id="dfn-direction">direction</dfn> (either
<code>outgoing direction</code> or <code>incoming direction</code>) as
inputs and generates a deterministic serialization for the
<a class="tref internalDFN" title="node_reference" href="#dfn-node_reference">node reference</a>.
</p>

<ol class="algorithm">
<li>If the <a class="tref internalDFN" title="label" href="#dfn-label">label</a> exists in the 
  <a class="tref internalDFN" title="processed_labels_map" href="#dfn-processed_labels_map">processed labels map</a>, terminate the algorithm as the 
  <a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1">serialization label</a> has already been created.
</li>
<li>Set the value associated with the <a class="tref internalDFN" title="label" href="#dfn-label">label</a> in the
  <a class="tref internalDFN" title="processed_labels_map" href="#dfn-processed_labels_map">processed labels map</a> to <code>true</code>.
</li>
<li>Generate the next <dfn title="serialization_label" id="dfn-serialization_label-1">serialization label</dfn> for the 
  <a class="tref internalDFN" title="label" href="#dfn-label">label</a> according to the
  <a href="#serialization-label-generation-algorithm">Serialization Label Generation Algorithm</a>.
</li>
<li>Create an empty array called the <a class="tref" title="list_of_unserialized_labels">list of unserialized labels</a>.
</li>
<li>For every <a class="tref internalDFN" title="label" href="#dfn-label">label</a> in a list, where the list the <a class="tref internalDFN" title="outgoing_list" href="#dfn-outgoing_list">outgoing list</a> if
the <a class="tref internalDFN" title="direction" href="#dfn-direction">direction</a> is <code>outgoing direction</code> and the
<a class="tref internalDFN" title="incoming_list" href="#dfn-incoming_list">incoming list</a> otherwise, if the <a class="tref internalDFN" title="label" href="#dfn-label">label</a> starts with
<code>_:</code>, it is the <dfn title="target_node_label" id="dfn-target_node_label">target node label</dfn>:
  <ol class="algorithm">
    <li>Look up the <a class="tref internalDFN" title="target_node_label" href="#dfn-target_node_label">target node label</a> in the 
      <a class="tref internalDFN" title="processed_labels_map" href="#dfn-processed_labels_map">processed labels map</a> and if a mapping exists,
      update the <a class="tref internalDFN" title="serialized_labels_map" href="#dfn-serialized_labels_map">serialized labels map</a> where the key is
      the value in the <a class="tref" title="serialization_map">serialization map</a> and the value is the
      <a class="tref internalDFN" title="target_node_label" href="#dfn-target_node_label">target node label</a>.</li>
    <li>Otherwise, add the <a class="tref internalDFN" title="target_node_label" href="#dfn-target_node_label">target node label</a> to the 
      <a class="tref" title="list_of_unserialized_labels">list of unserialized labels</a>.
  </li></ol>
</li> 
<li>Set the <dfn title="maximum_serialization_combinations" id="dfn-maximum_serialization_combinations">maximum serialization combinations</dfn> to 
  <code>1</code> or the length of the 
  <a class="tref" title="list_of_unserialized_labels">list of unserialized labels</a>, whichever is greater.</li>
<li>While the <a class="tref internalDFN" title="maximum_serialization_combinations" href="#dfn-maximum_serialization_combinations">maximum serialization combinations</a> is greater than
  <code>0</code>, perform the
  <a href="#combinatorial-serialization-algorithm">Combinatorial Serialization Algorithm</a>
  and decrement the <a class="tref internalDFN" title="maximum_serialization_combinations" href="#dfn-maximum_serialization_combinations">maximum serialization combinations</a> by
  <code>1</code> for each iteration.
</li></ol>

</div>

<div id="serialization-label-generation-algorithm" class="section">
<h4><span class="secno">6.11.10 </span>Serialization Label Generation Algorithm</h4>

<p>
The algorithm generates a <a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1">serialization label</a> given a 
<a class="tref internalDFN" title="label" href="#dfn-label">label</a> and a <a class="tref" title="mapping_count">mapping count</a>.
</p>

<li>
  <ol class="algorithm">
    <li>If the <a class="tref internalDFN" title="label" href="#dfn-label">label</a> starts with the string <code>_:c14n</code>,
      the <a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1">serialization label</a> is the letter <code>c</code>
      followed by the number that follows <code>_:c14n</code> in the
      <a class="tref internalDFN" title="label" href="#dfn-label">label</a>.</li>
    <li>Otherwise, the <a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1">serialization label</a> is the
      letter <code>s</code> followed by the string value of 
      <a class="tref" title="mapping_count">mapping count</a>. Increment the <a class="tref" title="mapping_count">mapping count</a> by
      <code>1</code> ensuring that the value persists across multiple
      invocations of this algorithm.</li>
  </ol>
</li>
</div>

<div id="combinatorial-serialization-algorithm" class="section">
<h4><span class="secno">6.11.11 </span>Combinatorial Serialization Algorithm</h4>

<p>
SerializeCombos() takes a <a class="tref internalDFN" title="label" href="#dfn-label">label</a>, 
a <a class="tref" title="serialization_map">serialization map</a>, a <a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1">serialization label</a>, a
<a class="tref internalDFN" title="processed_labels_map" href="#dfn-processed_labels_map">processed labels map</a>, a <a class="tref" title="serialization_map">serialization map</a>, 
a <a class="tref internalDFN" title="serialized_labels_map" href="#dfn-serialized_labels_map">serialized labels map</a>, and a 
<a class="tref" title="list_of_unserialized_labels">list of unserialized labels</a> as inputs and generates
deterministic serializations for all possible combinations of graphs.
</p>

<ol class="algorithm">
  <li>If the <a class="tref" title="list_of_unserialized_labels">list of unserialized labels</a> is not empty:
    <ol class="algorithm">
      <li>Copy the <a class="tref" title="serialization_map">serialization map</a> to the 
        <dfn title="serialization_map_copy" id="dfn-serialization_map_copy">serialization map copy</dfn>.</li>
      <li>Remove the first <a class="tref" title="unserialized_label">unserialized label</a> from the
        <a class="tref" title="list_of_unserialized_labels">list of unserialized labels</a> and create a new 
        <dfn title="new_serialization_label" id="dfn-new_serialization_label">new serialization label</dfn> according to the
        <a href="#serialization-label-generation-algorithm">Serialization Label Generation Algorithm</a>
        passing the <a class="tref" title="unserialized_label">unserialized label</a> and the 
        <a class="tref internalDFN" title="mapping_counter" href="#dfn-mapping_counter">mapping counter</a> as parameters.
      </li><li>Create a new key-value mapping in the 
        <a class="tref internalDFN" title="serialization_map_copy" href="#dfn-serialization_map_copy">serialization map copy</a> 
        where the key is the <a class="tref internalDFN" title="new_serialization_label" href="#dfn-new_serialization_label">new serialization label</a> and the value
        is the <a class="tref" title="unserialized_label">unserialized label</a>.
</li><li>Set the <dfn title="maximum_serialization_rotations" id="dfn-maximum_serialization_rotations">maximum serialization rotations</dfn> to 
  <code>1</code> or the length of the 
  <a class="tref" title="list_of_unserialized_labels">list of unserialized labels</a>, whichever is greater.</li>
<li>While the <a class="tref internalDFN" title="maximum_serialization_rotations" href="#dfn-maximum_serialization_rotations">maximum serialization rotations</a> is greater than
  <code>0</code>:
  <ol class="algorithm">
    <li>If this is the first iteration in the loop, perform the
      <a href="#combinatorial-serialization-algorithm">Combinatorial Serialization Algorithm</a>
      passing in the <a class="tref internalDFN" title="label" href="#dfn-label">label</a>, the <a class="tref internalDFN" title="serialization_map_copy" href="#dfn-serialization_map_copy">serialization map copy</a>,
      the <a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1">serialization label</a>, the
      <a class="tref internalDFN" title="processed_labels_map" href="#dfn-processed_labels_map">processed labels map</a>, 
      <a class="tref internalDFN" title="serialized_labels_map" href="#dfn-serialized_labels_map">serialized labels map</a>, and the
      <a class="tref" title="list_of_unserialized_labels">list of unserialized labels</a>.</li>
    <li>If this is not the first iteration in the loop, perform the
      <a href="#combinatorial-serialization-algorithm">Combinatorial Serialization Algorithm</a>
      passing in the <a class="tref internalDFN" title="label" href="#dfn-label">label</a>, the <a class="tref internalDFN" title="serialization_map_copy" href="#dfn-serialization_map_copy">serialization map copy</a>,
      the <a class="tref internalDFN" title="serialization_label" href="#dfn-serialization_label-1">serialization label</a>, and temporary copies of the
      <a class="tref internalDFN" title="processed_labels_map" href="#dfn-processed_labels_map">processed labels map</a>, 
      <a class="tref internalDFN" title="serialized_labels_map" href="#dfn-serialized_labels_map">serialized labels map</a>, and the
      <a class="tref" title="list_of_unserialized_labels">list of unserialized labels</a>.</li>
    <li>Decrement the <a class="tref internalDFN" title="maximum_serialization_rotations" href="#dfn-maximum_serialization_rotations">maximum serialization rotations</a> by
    <code>1</code> for each iteration.
  </li></ol></li>
  <li>If the <a class="tref" title="list_of_unserialized_labels">list of unserialized labels</a> is empty:
    <ol class="algorithm">
      <li>???Save an entry mapping from the bnode's 
serialization name to the reverse mapping (mapped) and its sorted keys then do SerializeMapping:
    <ol class="algorithm">
      <li>???If the serialization is lexicographically less than the current 
serialization or the current serialization is null, then iterate over the 
sorted keys, get the reverse-mapped adjacent bnode and recursively call 
SerializeNode on each iteration.</li>
      <li>???Do SerializeMapping then if the serialization is lexicographically 
less than the current serialization or the current serialization is null, then 
set it as the least serialization for the bnode in the given edge direction 
('property' or 'reference').</li>
    </ol>
  </li>
</ol>

</li></ol></li></ol></div>

<div id="mapping-serialization-algorithm" class="section">
<h4><span class="secno">6.11.12 </span>Mapping Serialization Algorithm</h4>

<p>
<a class="tref" title="map_of_all_labels">map of all labels</a>, <a class="tref" title="map_of_all_properties">map of all properties</a>,
<dfn title="key_stack" id="dfn-key_stack-1">key stack</dfn>, <dfn title="serialization_string_" id="dfn-serialization_string_">serialization string
</dfn></p>

<p>
SerializeMapping(mapping):
(This function incrementally updates the relation serialization for a mapping)
</p>

<ol class="algorithm">
  <li>If the <a class="tref" title="serialization_keys_stack">serialization keys stack</a> is not empty
    <ol class="algorithm">
      <li>Pop the <dfn title="list_of_serialization_keys" id="dfn-list_of_serialization_keys">list of serialization keys</dfn> off of the 
        <a class="tref" title="serialization_keys_stack">serialization keys stack</a>.</li>
      <li>For each <dfn title="serialization_key" id="dfn-serialization_key">serialization key</dfn> in the 
        <a class="tref internalDFN" title="list_of_serialization_keys" href="#dfn-list_of_serialization_keys">list of serialization keys</a>:
        <ol class="algorithm">
          <li>If the <a class="tref internalDFN" title="serialization_key" href="#dfn-serialization_key">serialization key</a> is not in the
            ???list of adjacent nodes???, push the 
            <a class="tref internalDFN" title="list_of_serialization_keys" href="#dfn-list_of_serialization_keys">list of serialization keys</a> onto the
            <a class="tref" title="serialization_keys_stack">serialization keys stack</a> and exit from this loop.</li>
          <li>If the <a class="tref internalDFN" title="serialization_key" href="#dfn-serialization_key">serialization key</a> is a key in the
            <a class="tref" title="completed_serialization_key_map">completed serialization key map</a>, a cycle has
            been detected. Append the concatenation of the <code>_</code> 
            character and the <a class="tref internalDFN" title="serialization_key" href="#dfn-serialization_key">serialization key</a> to the 
            <a class="tref internalDFN" title="serialization_string" href="#dfn-serialization_string">serialization string</a>.
          </li><li>Otherwise, serialize all outgoing and incoming edges in the
            graph by performing the following steps:
            <ol class="algorithm">
              <li>Mark the <a class="tref internalDFN" title="serialization_key" href="#dfn-serialization_key">serialization key</a> as being processed
                by adding a new key-value pair to the 
                <a class="tref" title="completed_serialization_key_map">completed serialization key map</a> where the key
                is the <a class="tref internalDFN" title="serialization_key" href="#dfn-serialization_key">serialization key</a> and the value is
                <code>true</code>.
                </li>
              <li>Set the <a class="tref" title="serialization_fragment">serialization fragment</a> to the value of
                the <a class="tref internalDFN" title="serialization_key" href="#dfn-serialization_key">serialization key</a>.</li>
              <li>Set the <a class="tref" title="list_of_adjacent_node_keys">list of adjacent node keys</a> by using the
                <a class="tref internalDFN" title="serialization_key" href="#dfn-serialization_key">serialization key</a> to look up the list in the
                <a class="tref" title="adjacent_node_keys_map">adjacent node keys map</a>.</li>
              <li>Set the <a class="tref" title="adjacent_node_label">adjacent node label</a> ???somehow???.</li>
              <li>If a mapping for the <a class="tref" title="adjacent_node_label">adjacent node label</a>
                exists in the <a class="tref" title="map_of_all_labels">map of all labels</a>:
                <ol class="algorithm">
                  <li>Append the result of the
                    <a href="">Label Serialization Algorithm</a> to the
                    <a class="tref" title="serialization_fragment">serialization fragment</a>.</li>
                </ol>
        </li></ol></li>
    </ol></li>
  
<!-- li>If there is an entry on the mapping's key stack, pop it and iterate over every key.</li>
  <li>For each key, if an entry for the key hasn't been added to the mapping yet, break out of the loop.</li>
  <li>Update the key stack entry's index.</li>
  <li>If the key has already been serialized, output "'_' + key" and continue.</li>
  <li>For each key, serialize the key then its associated bnode properties, then its bnode references. The entire property list is surrounded by '[' and ']' and so is the reference list. Individual properties/references are seperated by '|'. If a property is an array, all of the serializations are concatenated together with no joining delimiter. The '@subject' property is skipped. The property IRI is turtle-serialized. If a property or reference object is a bnode, it is serialized to '_:', otherwise the turtle serialization is used.</li>
  <li>Join all of the adjacent keys and add them to the serialization.</li>
  <li>Push the adjacent keys onto the key stack.</li>
  <li>Do SerializeMapping.</li  -->

</ol>

</li></ol></div>

<div id="label-serialization-algorithm" class="section">
<h4><span class="secno">6.11.13 </span>Label Serialization Algorithm</h4>

<p>
<a class="tref" title="map_of_properties">map of properties</a>, <dfn title="label_serialization" id="dfn-label_serialization">label serialization</dfn>,
<a class="tref internalDFN" title="label" href="#dfn-label">label</a>, <a class="tref" title="incoming_map">incoming map</a>, 
<dfn title="adjacent_node_labels" id="dfn-adjacent_node_labels">adjacent node labels</dfn>, <a class="tref internalDFN" title="key_stack" href="#dfn-key_stack-1">key stack</a>.
</p>

<ol class="algorithm">
  <li>Initialize the <a class="tref internalDFN" title="label_serialization" href="#dfn-label_serialization">label serialization</a> to an empty string.</li>
  <li>Append the <code>[</code> character to the 
    <a class="tref internalDFN" title="label_serialization" href="#dfn-label_serialization">label serialization</a>.</li>
  <li>Append all properties to the <a class="tref internalDFN" title="label_serialization" href="#dfn-label_serialization">label serialization</a> by 
    processing each key-value pair in the <a class="tref" title="map_of_properties">map of properties</a>, 
    excluding the
    <code>@subject</code> property ???do the map keys need to be sorted???:
    <ol class="algorithm">
      <li>Build a string using the pattern <code><</code><strong>KEY</strong><code>></code> 
        where <strong>KEY</strong> is the current key. Append string to the
        <a class="tref internalDFN" title="label_serialization" href="#dfn-label_serialization">label serialization</a>.</li>
      <li>The value may be a single object or an array of objects.
        Process all of the objects that are associated with the key, building
        an <dfn title="object_string" id="dfn-object_string">object string</dfn> for each item:
        <ol class="algorithm">
          <li>If the object contains an <code>@iri</code> key with a
            value that starts
            with <code>_:</code>, set the <a class="tref internalDFN" title="object_string" href="#dfn-object_string">object string</a> to
            the value <code>_:</code>. If the value does not
            start with <code>_:</code>, build the <a class="tref internalDFN" title="object_string" href="#dfn-object_string">object string</a> 
            using the pattern 
            <code><</code><strong>IRI</strong><code>></code> 
            where <strong>IRI</strong> is the value associated with the
            <code>@iri</code> key.</li>
          <li>If the object contains a <code>@literal</code> key and a
            <code>@datatype</code> key, build the <a class="tref internalDFN" title="object_string" href="#dfn-object_string">object string</a> 
            using the pattern 
            <code>"</code><strong>LITERAL</strong><code>"^^<</code><strong>DATATYPE</strong><code>></code>
            where <strong>LITERAL</strong> is the value associated with the
            <code>@literal</code> key and <strong>DATATYPE</strong> is the
            value associated with the <code>@datatype</code> key.</li>
          <li>If the object contains a <code>@literal</code> key and a
            <code>@language</code> key, build the <a class="tref internalDFN" title="object_string" href="#dfn-object_string">object string</a> 
            using the pattern 
            <code>"</code><strong>LITERAL</strong><code>"@</code><strong>LANGUAGE</strong>
            where <strong>LITERAL</strong> is the value associated with the
            <code>@literal</code> key and <strong>LANGUAGE</strong> is the
            value associated with the <code>@language</code> key.</li>
          <li>Otherwise, the value is a string. Build the 
            <a class="tref internalDFN" title="object_string" href="#dfn-object_string">object string</a> using the pattern 
            <code>"</code><strong>LITERAL</strong><code>"</code> 
            where <strong>LITERAL</strong> is the value associated with the
            current key.</li>
          <li>If this is the second iteration of the loop,
            append a <code>|</code> separator character to the
            <a class="tref internalDFN" title="label_serialization" href="#dfn-label_serialization">label serialization</a>.</li>
          <li>Append the <a class="tref internalDFN" title="object_string" href="#dfn-object_string">object string</a> to the 
            <a class="tref internalDFN" title="label_serialization" href="#dfn-label_serialization">label serialization</a>.</li>
        </ol>
    </li></ol>
  </li>
  <li>Append the <code>]</code> character to the 
    <a class="tref internalDFN" title="label_serialization" href="#dfn-label_serialization">label serialization</a>.</li>
  <li>Append the <code>[</code> character to the 
    <a class="tref internalDFN" title="label_serialization" href="#dfn-label_serialization">label serialization</a>.</li>
  <li>Append all incoming references for the current
    <a class="tref internalDFN" title="label" href="#dfn-label">label</a> to the <a class="tref internalDFN" title="label_serialization" href="#dfn-label_serialization">label serialization</a> by 
    processing all of the items associated with the <a class="tref internalDFN" title="label" href="#dfn-label">label</a>
    in the <a class="tref" title="incoming_map">incoming map</a>:
    <ol class="algorithm">
      <li>Build a <dfn title="reference_string" id="dfn-reference_string">reference string</dfn> 
        using the pattern <code><</code><strong>PROPERTY</strong><code>></code><code><</code><strong>REFERER</strong><code>></code>
        where <strong>PROPERTY</strong> is the property associated with the
        incoming reference and <strong>REFERER</strong> is either the subject of
        the node referring to the <a class="tref internalDFN" title="label" href="#dfn-label">label</a> in the incoming reference
        or <code>_:</code> if <strong>REFERER</strong> begins with
        <code>_:</code>.
      </li><li>If this is the second iteration of the loop,
        append a <code>|</code> separator character to the
        <a class="tref internalDFN" title="label_serialization" href="#dfn-label_serialization">label serialization</a>.</li>
      <li>Append the <a class="tref internalDFN" title="reference_string" href="#dfn-reference_string">reference string</a> to the 
        <a class="tref internalDFN" title="label_serialization" href="#dfn-label_serialization">label serialization</a>.</li>
    </ol>
  </li><li>Append the <code>]</code> character to the 
    <a class="tref internalDFN" title="label_serialization" href="#dfn-label_serialization">label serialization</a>.</li>
  <li>Append all <a class="tref internalDFN" title="adjacent_node_labels" href="#dfn-adjacent_node_labels">adjacent node labels</a> to the
    <a class="tref internalDFN" title="label_serialization" href="#dfn-label_serialization">label serialization</a> by concatenating the string value
    for all of them, one after the other, to the 
    <a class="tref internalDFN" title="label_serialization" href="#dfn-label_serialization">label serialization</a>.</li>
  <li>Push the <a class="tref internalDFN" title="adjacent_node_labels" href="#dfn-adjacent_node_labels">adjacent node labels</a> onto the 
    <a class="tref internalDFN" title="key_stack" href="#dfn-key_stack-1">key stack</a> and append the result of the
    <a href="#mapping-serialization-algorithm">Mapping Serialization Algorithm</a> 
    to the <a class="tref internalDFN" title="label_serialization" href="#dfn-label_serialization">label serialization</a>.
</li></ol>

</div>

</div>

<div id="data-round-tripping" class="section">

<h3><span class="secno">6.12 </span>Data Round Tripping</h3>

<p>When normalizing <strong>xsd:double</strong> values, implementers <em class="rfc2119" title="must">must</em>
ensure that the normalized value is a string. In order to generate the
string from a <strong>double</strong> value, output equivalent to the
<code>printf("%1.6e", value)</code> function in C <em class="rfc2119" title="must">must</em> be used where
<strong>"%1.6e"</strong> is the string formatter and <strong>value</strong>
is the value to be converted.</p>

<p>To convert the a double value in JavaScript, implementers can use the 
following snippet of code:</p>

<pre class="example">
// the variable 'value' below is the JavaScript native double value that is to be converted
(value).toExponential(6).replace(/(e(?:\+|-))([0-9])$/, '$10$2')</pre>

<p class="note">When data needs to be normalized, JSON-LD authors should
not use values that are going to undergo automatic conversion. This is due
to the lossy nature of <strong>xsd:double</strong> values.</p>

<p class="issue">Round-tripping data can be problematic if we mix and
match @coerce rules with JSON-native datatypes, like integers. Consider the 
following code example:</p>

<pre class="example">
var myObj = { "@context" : { 
                "number" : "http://example.com/vocab#number",
                "@coerce": {
                   "xsd:nonNegativeInteger": "number"
                }
              },
              "number" : 42 };

// Map the language-native object to JSON-LD
var jsonldText = jsonld.normalize(myObj);

// Convert the normalized object back to a JavaScript object
var myObj2 = jsonld.parse(jsonldText);</pre>

<p class="issue">At this point, myObj2 and myObj will have different
values for the "number" value. myObj will be the number 42, while
myObj2 will be the string "42". This type of data round-tripping
error can bite developers. We are currently wondering if having a
"coerce validation" phase in the parsing/normalization phases would be a 
good idea. It would prevent data round-tripping issues like the
one mentioned above.</p>

</div>

<div id="rdf-conversion" class="section">
<h3><span class="secno">6.13 </span>RDF Conversion</h3>

<p>A JSON-LD document <em class="rfc2119" title="may">may</em> be converted to any other RDF-compatible document
format using the algorithm specified in this section.</p>

<p>
  The JSON-LD Processing Model describes processing rules for extracting RDF
  from a JSON-LD document. Note that many uses of JSON-LD may not require 
  generation of RDF.
</p>

<p>
The processing algorithm described in this section is provided in
order to demonstrate how one might implement a JSON-LD to RDF processor. 
Conformant implementations are only required to produce the same type and
number of triples during the output process and are not required to 
implement the algorithm exactly as described.
</p>

<p class="issue">The RDF Conversion Algorithm is a work in progress.</p>

<div class="informative section" id="overview">
  <h4><span class="secno">6.13.1 </span>Overview</h4><p><em>This section is non-normative.</em></p>
  <p>
    JSON-LD is intended to have an easy to parse grammar that closely models existing
    practice in using JSON for describing object representations. This allows the use
    of existing libraries for parsing JSON in a document-oriented fashion, or can allow
    for stream-based parsing similar to SAX.
  </p>
  <p>
    As with other grammars used for describing <a class="tref internalDFN" title="Linked_Data" href="#dfn-linked_data">Linked Data</a>, a key concept is that of
    a <em>resource</em>. Resources may be of three basic types: <em>IRI</em>s, for describing
    externally named entities, <em>BNodes</em>, resources for which an external name does not
    exist, or is not known, and Literals, which describe terminal entities such as strings,
    dates and other representations having a lexical representation possibly including
    an explicit language or datatype.
  </p>
  <p>
    Data described with JSON-LD may be considered to be the representation of a graph made
    up of <a class="tref internalDFN" title="subject" href="#dfn-subject">subject</a> and <a class="tref internalDFN" title="object" href="#dfn-object">object</a> resources related via a <a class="tref internalDFN" title="property" href="#dfn-property">property</a> resource.
    However, specific implementations may choose to operate on the document as a normal
    JSON description of objects having attributes.
  </p>
</div>

<div id="rdf-conversion-algorithm-terms" class="section">
  <h4><span class="secno">6.13.2 </span>RDF Conversion Algorithm Terms</h4>
  <dl>
    <dt><dfn title="default_graph" id="dfn-default_graph">default graph</dfn></dt>
    <dd>
      the destination graph for all triples generated by JSON-LD markup.
    </dd>
  </dl>
</div>

<div id="rdf-conversion-algorithm" class="section">
  <h4><span class="secno">6.13.3 </span>RDF Conversion Algorithm</h4>
  <p>
    The algorithm below is designed for in-memory implementations with random access to <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a> elements.
  </p>
  <p>
    A conforming JSON-LD processor implementing RDF conversion <em class="rfc2119" title="must">must</em> implement a
    processing algorithm that results in the same <a class="tref internalDFN" title="default_graph" href="#dfn-default_graph">default graph</a> that the following
    algorithm generates:
  </p>

  <ol class="algorithm">
    <li id="processing-step-default-context">
      Create a new <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a> with with the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> set to the
      <a class="tref internalDFN" title="initial_context" href="#dfn-initial_context">initial context</a> and <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a> and <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>
      initialized to NULL.
    </li>

    <li id="processing-step-associative">
      If a <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a> is detected, perform the following steps:
      <ol class="algorithm">
        <li>
          If the <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a> has a <code>@context</code> key, process the local context as
          described in <a href="#context">Context</a>.
        </li>
        <li>
          Create a new <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a> by mapping the keys from the current <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a> using the
          <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> to new keys using the associated value from the current <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a>.
          Repeat the mapping until no entry is found within the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> for the key. Use the new
          <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a> in subsequent steps.
        </li>
        <li>
          If the <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a> has an <code>@iri</code> key, set the <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> by
          performing <a href="#iri-expansion">IRI Expansion</a> on the associated value. Generate a
          triple representing the <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and the
          <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a>. Return the <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> to the calling location.
          <p class="issue"><code>@iri</code> really just behaves the same as <code>@subject</code>, consider consolidating them.</p>
        </li>
        <li>
          If the <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a> has a <code>@literal</code> key, set the <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a>
          to a literal value as follows:
          <ol class="algorithm">
            <li>
              as a <a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">typed literal</a> if the <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a> contains a <code>@datatype</code> key
              after performing <a href="#iri-expansion">IRI Expansion</a> on the specified<code>@datatype</code>.
            </li>
            <li>
              otherwise, as a <a class="tref internalDFN" title="plain_literal" href="#dfn-plain_literal">plain literal</a>. If the <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a> contains
              a <code>@language</code> key, use it's value to set the language of the plain literal.
            </li>
            <li>
              Generate a triple representing the <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and the
              <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a>. Return the <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> to the calling location.
            </li>
          </ol>
        </li>
        <li id="processing-step-subject">If the <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a> has a <code>@subject</code> key:
          <ol class="algorithm">
            <li>
              If the value is a <a class="tref internalDFN" title="string" href="#dfn-string">string</a>, set the <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> to the result of performing
              <a href="#iri-expansion">IRI Expansion</a>. Generate a
              triple representing the <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and the
              <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a>. Set the <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a> to the <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a>.
            </li>
            <li>
              Create a new <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a> using copies of the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>,
              <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a> and <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and process the value
              starting at <a href="#processing-step-associative">Step 2</a>, set the <a class="tref" title="active__subject">active
              subject</a> to the result and proceed using the previous <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a>.
            </li>
          </ol>
        </li>
        <li>
          If the <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a> does not have a <code>@subject</code> key, set the <a class="tref" title="active__object">active
          object</a> to newly generated <dfn title="blank_node_identifier" id="dfn-blank_node_identifier">blank node identifier</dfn>. Generate a triple
          representing the <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and the
          <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a>. Set the <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a> to the <a class="tref" title="active__object">active
          object</a>.
        </li>
        <li>
          For each key in the <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a> that has not already been processed, perform
          the following steps:
          <ol class="algorithm">
            <li>
              If the key is <code>@type</code>, set the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> 
              to <code>rdf:type</code>.
            </li>
            <li>Otherwise, set the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> to the result of performing
            <a href="#iri-expansion">IRI Expansion</a> on the key.</li>
            <li>
              Create a new <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a> copies of the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>,
              <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a> and <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and process the value
              starting at <a href="#processing-step-associative">Step 2</a> and proceed using the
              previous <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a>.
            </li>
          </ol>
        </li>
        <li>
          Return the <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> to the calling location.
        </li>
      </ol>
    </li>

    <li>
      If a regular <a class="tref internalDFN" title="array" href="#dfn-array">array</a> is detected, process each value in the <a class="tref internalDFN" title="array" href="#dfn-array">array</a> by doing the following
      returning the result of processing the last value in the <a class="tref internalDFN" title="array" href="#dfn-array">array</a>:

      <ol class="algorithm">
        <li>
          Create a new <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a> using copies of the <a class="tref" title="active__context">active
          context</a>, <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a> and <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and process the value
          starting at <a href="#processing-step-associative">Step 2</a> then proceed using the previous
          <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a>.
        </li>
      </ol>
    </li>
    
    <li>
      If a <a class="tref internalDFN" title="string" href="#dfn-string">string</a> is detected:
      <ol class="algorithm">
        <li>
          If the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> is the target of a <code>@iri</code> coercion,
          set the <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> by
          performing <a href="#iri-expansion">IRI Expansion</a> on the string.
        </li>
        <li>
          Otherwise, if the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> is the target of coercion,
          set the <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> by creating a <a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">typed literal</a> using
          the string and the coercion key as the datatype IRI.
        </li>
        <li>
          Otherwise, set the <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a> to a <a class="tref internalDFN" title="plain_literal" href="#dfn-plain_literal">plain literal</a> value created from
          the string.
        </li>
      </ol>
      Generate a
      triple representing the <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and the
      <a class="tref internalDFN" title="active_object" href="#dfn-active_object">active object</a>.
    </li>
    
    <li>
      If a <a class="tref internalDFN" title="number" href="#dfn-number">number</a> is detected, generate a <a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">typed literal</a> using a string representation of
      the value with datatype set to either <code>xsd:integer</code> or
      <code>xsd:double</code>, depending on if the value contains a
      fractional and/or an exponential component. Generate a triple using the <a class="tref" title="active__subject">active
      subject</a>, <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> and the generated typed literal.
    </li>
    
    <li>
      Otherwise, if <strong>true</strong> or <strong>false</strong> is detected,
      generate a triple using the <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>
      and a <a class="tref internalDFN" title="typed_literal" href="#dfn-typed_literal">typed literal</a> value created from the string representation of the
      value with datatype set to <code>xsd:boolean</code>.
    </li>
  </ol>
</div>


<!--  THIS SHOULD BE SPLIT OUT INTO A SEPARATE DOCUMENT 

<section>
<h1>Best Practices</h1>

<p>The nature of Web programming allows one to use basic technologies, such as
JSON-LD, across a variety of systems and environments. This section attempts to
describe some of those environments and the way in which JSON-LD can be 
integrated in order to help alleviate certain development headaches.
</p>

<section>
<h2>JavaScript</h2>

<p class="issue">It is expected that JSON-LD will be used quite a bit in 
JavaScript environments, however, features like the expanded form for
object values mean that using JSON-LD directly in JavaScript may be 
annoying without a middleware layer such as a simple library that 
converts JSON-LD markup before JavaScript uses it. One could say that JSON-LD
is a good fit for the RDF API, which enables a variety of RDF-based
Web Applications, but some don't want to require that level of functionality 
just to use JSON-LD. The group is still discussing the best way to proceed, 
so input on how JSON-LD could more easily be utilized in JavaScript 
environments would be very much appreciated.
</p>
</section>

<section>
<h2>Schema-less Databases</h2>

<p class="issue">Databases such as CouchDB and MongoDB allow the creation of
schema-less data stores. RDF is a type of schema-less data model and thus
lends itself to databases such as CouchDB and MongoDB. Both of these databases
can use JSON-LD as their storage format. The group needs feedback from 
CouchDB and MongoDB experts regarding the usefulness of JSON-LD in those
environments.</p>

<p class="issue">MongoDB does not allow the '.' character to be used in
key names. This prevents developers from storing IRIs as keys, which also
prevents storage of the data in normalized form. While this issue can
be avoided by using <tref>CURIE</tref>s for key values, it is not known if this
mechanism is enough to allow JSON-LD to be used in MongoDB in a way that
is useful to developers.
</p>

 -->

</div>

</div>

<div id="experimental-concepts" class="section">

<!-- OddPage -->
<h2><span class="secno">7. </span>Experimental Concepts</h2>

<p class="issue">There are a few advanced concepts where it is not clear 
whether or not the JSON-LD specification is going to support the complexity 
necessary to support each concept. The entire section on Advanced Concepts 
should be considered as discussion points; it is merely a list of 
possibilities where all of the benefits and drawbacks have not been explored.
</p>

<div id="disjoint-graphs" class="section">
<h3><span class="secno">7.1 </span>Disjoint Graphs</h3>

<p>When serializing an RDF graph that contains two or more sections of the
graph which are entirely disjoint, one must use an <a class="tref internalDFN" title="array" href="#dfn-array">array</a> to express the graph
as two graphs. This may not be acceptable to some authors, who would rather
express the information as one graph. Since, by definition, disjoint graphs
require there to be two top-level objects, JSON-LD utilizes a mechanism that
allows disjoint graphs to be expressed using a single graph.</p>

<p>Assume the following RDF graph:</p>

<pre class="example">
&lt;http://example.org/people#john&gt; 
   &lt;http://www.w3.org/1999/02/22-rdf-syntax-ns#type&gt;
      &lt;http://xmlns.com/foaf/0.1/Person&gt; .
&lt;http://example.org/people#jane&gt; 
   &lt;http://www.w3.org/1999/02/22-rdf-syntax-ns#type&gt;
      &lt;http://xmlns.com/foaf/0.1/Person&gt; .</pre>

<p>Since the two subjects are entirely disjoint with one another, it is
impossible to express the RDF graph above using a single <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a>.</p>

<p>In JSON-LD, one can use the subject to express disjoint graphs as a 
single graph:</p>

<pre class="example">
{
  "@context": {
    "Person": "http://xmlns.com/foaf/0.1/Person"
  },
  "@subject": 
  [
    {
      "@subject": "http://example.org/people#john",
      "@type": "Person"
    },
    {
      "@subject": "http://example.org/people#jane",
      "@type": "Person"
    }
  ]
}</pre>

<p>A disjoint graph could also be expressed like so:</p>

<pre class="example">
[
  {
    "@subject": "http://example.org/people#john",
    "@type": "http://xmlns.com/foaf/0.1/Person"
  },
  {
    "@subject": "http://example.org/people#jane",
    "@type": "http://xmlns.com/foaf/0.1/Person"
  }
]</pre>

</div>

<div id="lists" class="section">
  <h3><span class="secno">7.2 </span>Lists</h3>
  <p>
    Because graphs do not describe ordering for links between nodes, multi-valued properties
    in JSON do not provide an ordering of the listed objects. For example, consider the following
    simple document:
  </p>
  <pre class="example">
{
...
  "@subject": "http://example.org/people#joebob",
  "nick": <span class="diff">["joe", "bob", "jaybee"]</span>,
...
}</pre>
  <p>
    This results in three triples being generated, each relating the subject to an individual
    object, with no inherent order. To address this issue, RDF-based languages, such as [<cite><a class="bibref" rel="biblioentry" href="#bib-TURTLE">TURTLE</a></cite>]
    use the concept of an <code>rdf:List</code> (as described in [<cite><a class="bibref" rel="biblioentry" href="#bib-RDF-SCHEMA">RDF-SCHEMA</a></cite>]). This uses a sequence
    of unlabeled nodes with properties describing a value, a null-terminated next property. Without
    specific syntactical support, this could be represented in JSON-LD as follows:
  </p>
  <pre class="example">
{
...
  "@subject": "http://example.org/people#joebob",
  "nick": <span class="diff">{</span>,
    <span class="diff">"@first": "joe"</span>,
    <span class="diff">"@rest": {</span>
      <span class="diff">"@first": "bob"</span>,
      <span class="diff">"@rest": {</span>
        <span class="diff">"@first": "jaybee"</span>,
        <span class="diff">"@rest": "@nil"</span>
        <span class="diff">}</span>
      <span class="diff">}</span>
    <span class="diff">}</span>
  <span class="diff">}</span>,
...
}</pre>
  <p>
    As this notation is rather unwieldy and the notion of ordered collections is rather important
    in data modeling, it is useful to have specific language support. In JSON-LD, a list may
    be represented using the <code>@list</code> keyword as follows:
  </p>
  <pre class="example">
{
...
  "@subject": "http://example.org/people#joebob",
  "foaf:nick": <span class="diff">{"@list": ["joe", "bob", "jaybee"]}</span>,
...
}</pre>
  <p>
    This describes the use of this <a class="tref internalDFN" title="array" href="#dfn-array">array</a> as being ordered, and order is maintained through
    normalization and RDF conversion. If every use of a given multi-valued property is a
    list, this may be abbreviated by adding an <code>@coerce</code> term:
  </p>
  <pre class="example">
{
  <span class="diff">"@context": {</span>
    ...
    <span class="diff">"@context": {</span>
      <span class="diff">"@list": ["foaf:nick"]</span>
    <span class="diff">}</span>
  <span class="diff">}</span>,
...
  "@subject": "http://example.org/people#joebob",
  "foaf:nick": <span class="diff">["joe", "bob", "jaybee"]</span>,
...
}</pre>
  <div id="expansion-2" class="section"><h4 id="list-expansion"><span class="secno">7.2.1 </span>Expansion</h4>
    <p class="issue">TBD.</p>
  </div>
  <div id="normalization-2" class="section"><h4 id="list-normalization"><span class="secno">7.2.2 </span>Normalization</h4>
    <p class="issue">TBD.</p>
  </div>
  <div id="rdf-conversion-1" class="section"><h4 id="list-rdf"><span class="secno">7.2.3 </span>RDF Conversion</h4>
    <p>
      To support RDF Conversion of lists, <a href="#rdf-conversion-algorithm">RDF Conversion Algorithm</a>
      is updated as follows:
    </p>
    <ol class="algorithm update">
      <li>
        <span class="list-number">2.4a.</span>
        If the <a class="tref internalDFN" title="JSON_object" href="#dfn-json_object">JSON object</a> has a <code>@list</code> key and the value is an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>
        process the value as a list starting at <a href="#processing-step-list">Step 3a</a>.
      </li>
      <li>
        <span class="list-number">2.7.3.</span>
        Create a new <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a> copies of the <a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a>,
        <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a> and <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>.
        <ol class="algorithm">
          <li>
            If the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a> is the target of a <code>@list</code> coercion,
            and the value is an <a class="tref internalDFN" title="array" href="#dfn-array">array</a>,
            process the value as a list starting at <a href="#processing-step-list">Step 3a</a>.
          </li>
          <li>
            Otherwise, process the value starting at
            <a href="#processing-step-associative">Step 2</a>.
          </li>
          <li>Proceed using the previous <a class="tref internalDFN" title="processor_state" href="#dfn-processor_state">processor state</a>.</li>
        </ol>
      </li>
      <li id="processing-step-list">
        <span class="list-number">3a.</span>
        Generate an RDF List by linking
        each element of the list using <code>rdf:first</code> and <code>rdf:next</code>, terminating the list with <code>rdf:nil</code>
        using the following sequence:
        <ol class="algorithm">
          <li>
            If the list has no element, generate a triple using the <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>
            and <code>rdf:nil</code>.
          </li>
          <li>
            Otherwise, generate a triple using using the <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>
            and a newly generated BNode identified as <em>first <dfn title="blank_node_identifier" id="dfn-blank_node_identifier-1">blank node identifier</dfn></em>.
          </li>
          <li>
            For each element other than the last element in the list:
            <ol class="algorithm">
              <li>Create a processor state using the active context, <em>first <dfn title="blank_node_identifier" id="dfn-blank_node_identifier-2">blank node identifier</dfn></em> as the <a class="tref internalDFN" title="active_subject" href="#dfn-active_subject">active subject</a>, and <code>rdf:first</code> as the <a class="tref internalDFN" title="active_property" href="#dfn-active_property">active property</a>.</li>
              <li>Unless this is the last element in the list, generate a new BNode identified as <em>rest <dfn title="blank_node_identifier" id="dfn-blank_node_identifier-3">blank node identifier</dfn></em>, otherwise use <code>rdf:nil</code>.</li>
              <li>Generate a new triple using <em>first <dfn title="blank_node_identifier" id="dfn-blank_node_identifier-4">blank node identifier</dfn></em>, <code>rdf:rest</code> and <em>rest <dfn title="blank_node_identifier" id="dfn-blank_node_identifier-5">blank node identifier</dfn></em>.</li>
              <li>Set <em>first <dfn title="blank_node_identifier" id="dfn-blank_node_identifier-6">blank node identifier</dfn></em> to <em>rest <dfn title="blank_node_identifier" id="dfn-blank_node_identifier-7">blank node identifier</dfn></em>.</li>
            </ol>
          </li>
        </ol>
      </li>
    </ol>
  </div>
</div>

</div>

<div class="appendix section" id="markup-examples">

<!-- OddPage -->
<h2><span class="secno">A. </span>Markup Examples</h2>

<p>The JSON-LD markup examples below demonstrate how JSON-LD can be used to
express semantic data marked up in other languages such as RDFa, Microformats,
and Microdata. These sections are merely provided as proof that JSON-LD is
very flexible in what it can express across different Linked Data approaches.
</p>

<div id="rdfa" class="section">
<h3><span class="secno">A.1 </span>RDFa</h3>

<p>The following example describes three people with their respective names and
homepages.</p>

<pre class="example">
&lt;div <span class="diff">prefix="foaf: http://xmlns.com/foaf/0.1/"</span>&gt;
   &lt;ul&gt;
      &lt;li <span class="diff">typeof="foaf:Person"</span>&gt;
        &lt;a <span class="diff">rel="foaf:homepage" href="http://example.com/bob/" property="foaf:name" </span>&gt;Bob&lt;/a&gt;
      &lt;/li&gt;
      &lt;li <span class="diff">typeof="foaf:Person"</span>&gt;
        &lt;a <span class="diff">rel="foaf:homepage" href="http://example.com/eve/" property="foaf:name" </span>&gt;Eve&lt;/a&gt;
      &lt;/li&gt;
      &lt;li <span class="diff">typeof="foaf:Person"</span>&gt;
        &lt;a <span class="diff">rel="foaf:homepage" href="http://example.com/manu/" property="foaf:name" </span>&gt;Manu&lt;/a&gt;
      &lt;/li&gt;
   &lt;/ul&gt;
&lt;/div&gt;</pre>

<p>An example JSON-LD implementation is described below, however, there are
other ways to mark-up this information such that the context is not
repeated.</p>

<pre class="example">
{
  "@context": { "foaf": "http://xmlns.com/foaf/0.1/"},
  "@subject": [
   {
     "@subject": "_:bnode1",
     "@type": "foaf:Person",
     "foaf:homepage": "http://example.com/bob/",
     "foaf:name": "Bob"
   },
   {
     "@subject": "_:bnode2",
     "@type": "foaf:Person",
     "foaf:homepage": "http://example.com/eve/",
     "foaf:name": "Eve"
   },
   {
     "@subject": "_:bnode3",
     "@type": "foaf:Person",
     "foaf:homepage": "http://example.com/manu/",
     "foaf:name": "Manu"
   }
  ]
}</pre>

</div>

<div id="microformats" class="section">
<h3><span class="secno">A.2 </span>Microformats</h3>

<p>The following example uses a simple Microformats hCard example to express
how the Microformat is represented in JSON-LD.</p>

<pre class="example">
&lt;div class="vcard"&gt;
 &lt;a class="url fn" href="http://tantek.com/"&gt;Tantek Çelik&lt;/a&gt;
&lt;/div&gt;</pre>

<p>The representation of the hCard expresses the Microformat terms in the
context and uses them directly for the <code>url</code> and <code>fn</code>
properties. Also note that the Microformat to JSON-LD processor has 
generated the proper URL type for <code>http://tantek.com</code>.</p>

<pre class="example">
{
  "@context": 
  {
    "vcard": "http://microformats.org/profile/hcard#vcard",
    "url": "http://microformats.org/profile/hcard#url",
    "fn": "http://microformats.org/profile/hcard#fn",
    "@coerce": { "xsd:anyURI": "url" }
  },
  "@subject": "_:bnode1",
  "@type": "vcard",
  "url": "http://tantek.com/",
  "fn": "Tantek Çelik"
}</pre>

</div>

<div id="microdata" class="section">
<h3><span class="secno">A.3 </span>Microdata</h3>

<p>The Microdata example below expresses book information as a Microdata Work
item.
</p>

<pre class="example">
&lt;dl itemscope
    itemtype="http://purl.org/vocab/frbr/core#Work"
    itemid="http://purl.oreilly.com/works/45U8QJGZSQKDH8N"&gt;
 &lt;dt&gt;Title&lt;/dt&gt;
 &lt;dd&gt;&lt;cite itemprop="http://purl.org/dc/terms/title"&gt;Just a Geek&lt;/cite&gt;&lt;/dd&gt;
 &lt;dt&gt;By&lt;/dt&gt;
 &lt;dd&gt;&lt;span itemprop="http://purl.org/dc/terms/creator"&gt;Wil Wheaton&lt;/span&gt;&lt;/dd&gt;
 &lt;dt&gt;Format&lt;/dt&gt;
 &lt;dd itemprop="http://purl.org/vocab/frbr/core#realization"
     itemscope
     itemtype="http://purl.org/vocab/frbr/core#Expression"
     itemid="http://purl.oreilly.com/products/9780596007683.BOOK"&gt;
  &lt;link itemprop="http://purl.org/dc/terms/type" href="http://purl.oreilly.com/product-types/BOOK"&gt;
  Print
 &lt;/dd&gt;
 &lt;dd itemprop="http://purl.org/vocab/frbr/core#realization"
     itemscope
     itemtype="http://purl.org/vocab/frbr/core#Expression"
     itemid="http://purl.oreilly.com/products/9780596802189.EBOOK"&gt;
  &lt;link itemprop="http://purl.org/dc/terms/type" href="http://purl.oreilly.com/product-types/EBOOK"&gt;
  Ebook
 &lt;/dd&gt;
&lt;/dl&gt;</pre>

<p>Note that the JSON-LD representation of the Microdata information stays
true to the desires of the Microdata community to avoid contexts and
instead refer to items by their full IRI.</p>

<pre class="example">
[
  {
    "@subject": "http://purl.oreilly.com/works/45U8QJGZSQKDH8N",
    "@type": "http://purl.org/vocab/frbr/core#Work",
    "http://purl.org/dc/terms/title": "Just a Geek",
    "http://purl.org/dc/terms/creator": "Whil Wheaton",
    "http://purl.org/vocab/frbr/core#realization": 
      ["http://purl.oreilly.com/products/9780596007683.BOOK", "http://purl.oreilly.com/products/9780596802189.EBOOK"]
  },
  {
    "@subject": "http://purl.oreilly.com/products/9780596007683.BOOK",
    "@type": "http://purl.org/vocab/frbr/core#Expression",
    "http://purl.org/dc/terms/type": "http://purl.oreilly.com/product-types/BOOK"
  },
  {
    "@subject": "http://purl.oreilly.com/products/9780596802189.EBOOK",
    "@type": "http://purl.org/vocab/frbr/core#Expression",
    "http://purl.org/dc/terms/type": "http://purl.oreilly.com/product-types/EBOOK"
  }
]</pre>
</div>

<div class="appendix section" id="mashing-up-vocabularies">
<h3><span class="secno">A.4 </span>Mashing Up Vocabularies</h3>

<p>Developers would also benefit by allowing other vocabularies to be used
automatically with their JSON API. There are over 200 
Vocabulary Documents that are available for use on the Web today. Some
of these vocabularies are:
</p>

<ul>
   <li>RDF - for describing information about objects on the semantic web.</li>
   <li>RDFS - for expressing things like labels and comments.</li>
   <li>XSD - for specifying basic types like strings, integers, dates and times.</li>
   <li>Dublin Core - for describing creative works.</li>
   <li>FOAF - for describing social networks.</li>
   <li>Calendar - for specifying events.</li>
   <li>SIOC - for describing discussions on blogs and websites.</li>
   <li>CCrel - for describing Creative Commons and other types of licenses.</li>
   <li>GEO - for describing geographic location.</li>
   <li>VCard - for describing organizations and people.</li>
   <li>DOAP - for describing projects.</li>
</ul>

<p>You can use these vocabularies in combination, like so:</p>

<pre class="example">
{
  "<span class="diff">@type</span>": "<span class="diff">foaf:Person</span>",
  "<span class="diff">foaf:name</span>": "Manu Sporny",
  "<span class="diff">foaf:homepage</span>": "http://manu.sporny.org/",
  "<span class="diff">sioc:avatar</span>": "http://twitter.com/account/profile_image/manusporny"
}</pre>

<p>Developers can also specify their own Vocabulary documents by modifying the 
<a class="tref internalDFN" title="active_context" href="#dfn-active_context">active context</a> in-line using the <code>@context</code> keyword, 
like so:</p>

<pre class="example">
{
  <span class="diff">"@context": { "myvocab": "http://example.org/myvocab#" }</span>,
  "@type": "foaf:Person",
  "foaf:name": "Manu Sporny",
  "foaf:homepage": "http://manu.sporny.org/",
  "sioc:avatar": "http://twitter.com/account/profile_image/manusporny"<span class="diff">,
  "myvocab:personality": "friendly"</span>
}</pre>

<p>The <code>@context</code> keyword is used to change how the JSON-LD
processor evaluates key-value pairs. In this case, it was used to
map one string ('myvocab') to another string, which is interpreted as
a <a class="tref internalDFN" title="IRI" href="#dfn-iri">IRI</a>. In the example above, the <code>myvocab</code> string is replaced 
with "<code>http://example.org/myvocab#</code>" when it
is detected. In the example above, "<code>myvocab:personality</code>" would
expand to "<code>http://example.org/myvocab#personality</code>".</p>

<p>This mechanism is a short-hand for RDF, called a <a class="tref internalDFN" title="CURIE" href="#dfn-curie">CURIE</a>, and provides
developers an unambiguous way to map any JSON value to RDF.</p><p>

</p></div>

<div class="appendix section" id="acknowledgements">
<h3><span class="secno">A.5 </span>Acknowledgements</h3>

<p>The editors would like to thank Mark Birbeck, who provided a great deal of 
the initial push behind the JSON-LD work via his work on RDFj, 
Dave Longley, Dave Lehn and Mike Johnson who reviewed, provided feedback, and 
performed several implementations of the specification, and Ian Davis, who 
created RDF/JSON. Thanks also to Nathan Rixham, Bradley P. Allen,
Kingsley Idehen, Glenn McDonald, Alexandre Passant, Danny Ayers, Ted
Thibodeau Jr., Olivier Grisel, Niklas Lindström, Markus Lanthaler, and Richard 
Cyganiak for their input on the specification. Another huge thank you goes out
to Dave Longley who designed many of the algorithms used in this specification,
including the normalization algorithm which was a monumentally difficult 
design challenge.
</p>
</div>




</div><div id="references" class="appendix section">
<!-- OddPage -->
<h2><span class="secno">B. </span>References</h2><div id="normative-references" class="section"><h3><span class="secno">B.1 </span>Normative references</h3><dl class="bibliography"><dt id="bib-BCP47">[BCP47]</dt><dd>A. Phillips, M. Davis. <a href="http://tools.ietf.org/rfc/bcp/bcp47.txt"><cite>Tags for Identifying Languages</cite></a> September 2009. IETF Best Current Practice. URL: <a href="http://tools.ietf.org/rfc/bcp/bcp47.txt">http://tools.ietf.org/rfc/bcp/bcp47.txt</a>
</dd><dt id="bib-RDF-CONCEPTS">[RDF-CONCEPTS]</dt><dd>Graham Klyne; Jeremy J. Carroll. <a href="http://www.w3.org/TR/2004/REC-rdf-concepts-20040210"><cite>Resource Description Framework (RDF): Concepts and Abstract Syntax.</cite></a> 10 February 2004. W3C Recommendation. URL: <a href="http://www.w3.org/TR/2004/REC-rdf-concepts-20040210">http://www.w3.org/TR/2004/REC-rdf-concepts-20040210</a> 
</dd><dt id="bib-RFC3986">[RFC3986]</dt><dd>T. Berners-Lee; R. Fielding; L. Masinter. <a href="http://www.ietf.org/rfc/rfc3986.txt"><cite>Uniform Resource Identifier (URI): Generic Syntax.</cite></a> January 2005. Internet RFC 3986. URL: <a href="http://www.ietf.org/rfc/rfc3986.txt">http://www.ietf.org/rfc/rfc3986.txt</a> 
</dd><dt id="bib-RFC3987">[RFC3987]</dt><dd>M. Dürst; M. Suignard. <a href="http://www.ietf.org/rfc/rfc3987.txt"><cite>Internationalized Resource Identifiers (IRIs).</cite></a> January 2005. Internet RFC 3987. URL: <a href="http://www.ietf.org/rfc/rfc3987.txt">http://www.ietf.org/rfc/rfc3987.txt</a> 
</dd><dt id="bib-RFC4627">[RFC4627]</dt><dd>D. Crockford. <a href="http://www.ietf.org/rfc/rfc4627.txt"><cite>The application/json Media Type for JavaScript Object Notation (JSON)</cite></a> July 2006. Internet RFC 4627. URL: <a href="http://www.ietf.org/rfc/rfc4627.txt">http://www.ietf.org/rfc/rfc4627.txt</a>
</dd><dt id="bib-WEBIDL">[WEBIDL]</dt><dd>Cameron McCormack. <a href="http://www.w3.org/TR/2008/WD-WebIDL-20081219"><cite>Web IDL.</cite></a> 19 December 2008. W3C Working Draft. (Work in progress.) URL: <a href="http://www.w3.org/TR/2008/WD-WebIDL-20081219">http://www.w3.org/TR/2008/WD-WebIDL-20081219</a> 
</dd></dl></div><div id="informative-references" class="section"><h3><span class="secno">B.2 </span>Informative references</h3><dl class="bibliography"><dt id="bib-ECMA-262">[ECMA-262]</dt><dd><a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm"><cite>ECMAScript Language Specification, Third Edition.</cite></a> December 1999. URL: <a href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">http://www.ecma-international.org/publications/standards/Ecma-262.htm</a> 
</dd><dt id="bib-MICRODATA">[MICRODATA]</dt><dd>Ian Hickson; et al. <a href="http://www.w3.org/TR/microdata/"><cite>Microdata</cite></a> 04 March 2010. W3C Working Draft. URL: <a href="http://www.w3.org/TR/microdata/">http://www.w3.org/TR/microdata/</a> 
</dd><dt id="bib-MICROFORMATS">[MICROFORMATS]</dt><dd><a href="http://microformats.org"><cite>Microformats</cite></a>. URL: <a href="http://microformats.org">http://microformats.org</a> 
</dd><dt id="bib-RDF-SCHEMA">[RDF-SCHEMA]</dt><dd>Dan Brickley; Ramanathan V. Guha. <a href="http://www.w3.org/TR/2004/REC-rdf-schema-20040210"><cite>RDF Vocabulary Description Language 1.0: RDF Schema.</cite></a> 10 February 2004. W3C Recommendation. URL: <a href="http://www.w3.org/TR/2004/REC-rdf-schema-20040210">http://www.w3.org/TR/2004/REC-rdf-schema-20040210</a> 
</dd><dt id="bib-RDFA-CORE">[RDFA-CORE]</dt><dd>Shane McCarron; et al. <a href="http://www.w3.org/TR/2011/WD-rdfa-core-20110331"><cite>RDFa Core 1.1: Syntax and processing rules for embedding RDF through attributes.</cite></a> 31 March 2011. W3C Working Draft. URL: <a href="http://www.w3.org/TR/2011/WD-rdfa-core-20110331">http://www.w3.org/TR/2011/WD-rdfa-core-20110331</a> 
</dd><dt id="bib-TURTLE">[TURTLE]</dt><dd>David Beckett, Tim Berners-Lee. <a href="http://www.w3.org/TeamSubmission/turtle/"><cite>Turtle: Terse RDF Triple Language.</cite></a> January 2008. W3C Team Submission. URL: <a href="http://www.w3.org/TeamSubmission/turtle/">http://www.w3.org/TeamSubmission/turtle/</a> 
</dd></dl></div></div></body></html>
